Import Cobalt 3.11337
diff --git a/src/base/file_util_starboard.cc b/src/base/file_util_starboard.cc
index 0c6511a..a2e9b2b 100644
--- a/src/base/file_util_starboard.cc
+++ b/src/base/file_util_starboard.cc
@@ -193,8 +193,8 @@
}
base::PlatformFile destination_file = base::CreatePlatformFileUnsafe(
- to_path, base::PLATFORM_FILE_CREATE | base::PLATFORM_FILE_WRITE, NULL,
- NULL);
+ to_path, base::PLATFORM_FILE_CREATE_ALWAYS | base::PLATFORM_FILE_WRITE,
+ NULL, NULL);
if (destination_file == base::kInvalidPlatformFileValue) {
DPLOG(ERROR) << "CopyFile(): Unable to open destination file: "
<< to_path.value();
diff --git a/src/cobalt/base/base.gyp b/src/cobalt/base/base.gyp
index a2f0dda..a2822ab 100644
--- a/src/cobalt/base/base.gyp
+++ b/src/cobalt/base/base.gyp
@@ -31,6 +31,7 @@
'c_val.h',
'c_val_time_interval_entry_stats.h',
'c_val_time_interval_timer.h',
+ 'deep_link_event.h',
'do_main.h',
'do_main_starboard.h',
'event.h',
diff --git a/src/cobalt/base/c_val.h b/src/cobalt/base/c_val.h
index c4bcc0c..7331781 100644
--- a/src/cobalt/base/c_val.h
+++ b/src/cobalt/base/c_val.h
@@ -249,6 +249,7 @@
{10LL * 1024LL * 1024LL * 1024LL, 1024LL * 1024LL * 1024LL, "GB"},
{10LL * 1024LL * 1024LL, 1024LL * 1024LL, "MB"},
{10LL * 1024LL, 1024LL, "KB"},
+ {0LL, 1L, "B"},
};
return ThresholdList<cval::SizeInBytes>(thresholds, arraysize(thresholds));
}
@@ -291,21 +292,23 @@
if (negative) {
oss << "-";
}
+
+ oss << std::fixed << std::setprecision(1) << std::setfill('0');
if (value_in_us > kHour) {
- oss << value_in_us / kHour << ":" << std::setfill('0') << std::setw(2)
- << (value_in_us % kHour) / kMinute << ":" << std::setfill('0')
+ oss << value_in_us / kHour << ":" << std::setw(2)
+ << (value_in_us % kHour) / kMinute << ":"
<< std::setw(2) << (value_in_us % kMinute) / kSecond << "h";
} else if (value_in_us > kMinute) {
- oss << value_in_us / kMinute << ":" << std::setfill('0') << std::setw(2)
+ oss << value_in_us / kMinute << ":" << std::setw(2)
<< (value_in_us % kMinute) / kSecond << "m";
- } else if (value_in_us > kSecond * 10) {
- oss << value_in_us / kSecond << "s";
- } else if (value_in_us > kMillisecond * 2) {
- oss << value_in_us / kMillisecond << "ms";
- } else if (value_in_us > 0) {
- oss << value_in_us << "us";
+ } else if (value_in_us > kSecond) {
+ oss << std::setw(1)
+ << static_cast<double>(value_in_us) / kSecond << "s";
+ } else if (value_in_us > kMillisecond) {
+ oss << std::setw(1)
+ << static_cast<double>(value_in_us) / kMillisecond << "ms";
} else {
- oss << value_in_us;
+ oss << value_in_us << "us";
}
return oss.str();
diff --git a/src/cobalt/base/c_val_test.cc b/src/cobalt/base/c_val_test.cc
index 9751266..c1941d3 100644
--- a/src/cobalt/base/c_val_test.cc
+++ b/src/cobalt/base/c_val_test.cc
@@ -16,6 +16,7 @@
#include <limits>
+#include "base/time.h"
#include "cobalt/base/c_val.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
@@ -64,7 +65,27 @@
base::CValManager* cvm = base::CValManager::GetInstance();
base::optional<std::string> result = cvm->GetValueAsPrettyString(cval_name);
EXPECT_TRUE(result);
- EXPECT_EQ(*result, "4095MB");
+ EXPECT_EQ(*result, "4294M");
+}
+
+TEST(CValTest, RegisterAndPrintU32Zero) {
+ const std::string cval_name = "32-bit unsigned int";
+ const uint32_t cval_value = 0;
+ base::CVal<uint32_t> cval(cval_name, cval_value, "Description.");
+ base::CValManager* cvm = base::CValManager::GetInstance();
+ base::optional<std::string> result = cvm->GetValueAsPrettyString(cval_name);
+ EXPECT_TRUE(result);
+ EXPECT_EQ(*result, "0");
+}
+
+TEST(CValTest, RegisterAndPrintU32K) {
+ const std::string cval_name = "32-bit unsigned int";
+ const uint32_t cval_value = 50000;
+ base::CVal<uint32_t> cval(cval_name, cval_value, "Description.");
+ base::CValManager* cvm = base::CValManager::GetInstance();
+ base::optional<std::string> result = cvm->GetValueAsPrettyString(cval_name);
+ EXPECT_TRUE(result);
+ EXPECT_EQ(*result, "50K");
}
TEST(CValTest, RegisterAndPrintU64) {
@@ -74,7 +95,7 @@
base::CValManager* cvm = base::CValManager::GetInstance();
base::optional<std::string> result = cvm->GetValueAsPrettyString(cval_name);
EXPECT_TRUE(result);
- EXPECT_EQ(*result, "17592186044415MB");
+ EXPECT_EQ(*result, "18446744073709M");
}
TEST(CValTest, RegisterAndPrintS32) {
@@ -97,6 +118,266 @@
EXPECT_EQ(*result, "-9223372036854775808");
}
+TEST(CValTest, RegisterAndPrintSizeInBytesB) {
+ const std::string cval_name = "SizeInBytes";
+ cval::SizeInBytes cval_value(500);
+ base::CVal<cval::SizeInBytes> cval(cval_name, cval_value, "Description.");
+ base::CValManager* cvm = base::CValManager::GetInstance();
+ base::optional<std::string> result = cvm->GetValueAsPrettyString(cval_name);
+ EXPECT_TRUE(result);
+ EXPECT_EQ(*result, "500B");
+}
+
+TEST(CValTest, RegisterAndPrintSizeInBytesZero) {
+ const std::string cval_name = "SizeInBytes";
+ cval::SizeInBytes cval_value(0);
+ base::CVal<cval::SizeInBytes> cval(cval_name, cval_value, "Description.");
+ base::CValManager* cvm = base::CValManager::GetInstance();
+ base::optional<std::string> result = cvm->GetValueAsPrettyString(cval_name);
+ EXPECT_TRUE(result);
+ EXPECT_EQ(*result, "0B");
+}
+
+TEST(CValTest, RegisterAndPrintSizeInBytesKB) {
+ const std::string cval_name = "SizeInBytes";
+ cval::SizeInBytes cval_value(50000UL);
+ base::CVal<cval::SizeInBytes> cval(cval_name, cval_value, "Description.");
+ base::CValManager* cvm = base::CValManager::GetInstance();
+ base::optional<std::string> result = cvm->GetValueAsPrettyString(cval_name);
+ EXPECT_TRUE(result);
+ EXPECT_EQ(*result, "48KB");
+}
+
+TEST(CValTest, RegisterAndPrintSizeInBytesMB) {
+ const std::string cval_name = "SizeInBytes";
+ cval::SizeInBytes cval_value(50000000UL);
+ base::CVal<cval::SizeInBytes> cval(cval_name, cval_value, "Description.");
+ base::CValManager* cvm = base::CValManager::GetInstance();
+ base::optional<std::string> result = cvm->GetValueAsPrettyString(cval_name);
+ EXPECT_TRUE(result);
+ EXPECT_EQ(*result, "47MB");
+}
+
+TEST(CValTest, RegisterAndPrintSizeInBytesGB) {
+ const std::string cval_name = "SizeInBytes";
+ cval::SizeInBytes cval_value(50000000000UL);
+ base::CVal<cval::SizeInBytes> cval(cval_name, cval_value, "Description.");
+ base::CValManager* cvm = base::CValManager::GetInstance();
+ base::optional<std::string> result = cvm->GetValueAsPrettyString(cval_name);
+ EXPECT_TRUE(result);
+ EXPECT_EQ(*result, "46GB");
+}
+
+TEST(CValTest, RegisterAndPrintTimeDeltaMicroseconds) {
+ const std::string cval_name = "TimeDelta";
+ base::TimeDelta cval_value(base::TimeDelta::FromMicroseconds(50));
+ base::CVal<base::TimeDelta> cval(cval_name, cval_value, "Description.");
+ base::CValManager* cvm = base::CValManager::GetInstance();
+ base::optional<std::string> result = cvm->GetValueAsPrettyString(cval_name);
+ EXPECT_TRUE(result);
+ EXPECT_EQ(*result, "50us");
+}
+
+TEST(CValTest, RegisterAndPrintTimeDeltaZero) {
+ const std::string cval_name = "TimeDelta";
+ base::TimeDelta cval_value(base::TimeDelta::FromMicroseconds(0));
+ base::CVal<base::TimeDelta> cval(cval_name, cval_value, "Description.");
+ base::CValManager* cvm = base::CValManager::GetInstance();
+ base::optional<std::string> result = cvm->GetValueAsPrettyString(cval_name);
+ EXPECT_TRUE(result);
+ EXPECT_EQ(*result, "0us");
+}
+
+TEST(CValTest, RegisterAndPrintTimeDeltaMilliseconds) {
+ const std::string cval_name = "TimeDelta";
+ base::TimeDelta cval_value(base::TimeDelta::FromMilliseconds(50));
+ base::CVal<base::TimeDelta> cval(cval_name, cval_value, "Description.");
+ base::CValManager* cvm = base::CValManager::GetInstance();
+ base::optional<std::string> result = cvm->GetValueAsPrettyString(cval_name);
+ EXPECT_TRUE(result);
+ EXPECT_EQ(*result, "50.0ms");
+}
+
+TEST(CValTest, RegisterAndPrintTimeDeltaMillisecondsSingleDigit) {
+ const std::string cval_name = "TimeDelta";
+ base::TimeDelta cval_value(base::TimeDelta::FromMilliseconds(5));
+ base::CVal<base::TimeDelta> cval(cval_name, cval_value, "Description.");
+ base::CValManager* cvm = base::CValManager::GetInstance();
+ base::optional<std::string> result = cvm->GetValueAsPrettyString(cval_name);
+ EXPECT_TRUE(result);
+ EXPECT_EQ(*result, "5.0ms");
+}
+
+TEST(CValTest, RegisterAndPrintTimeDeltaMillisecondsFraction) {
+ const std::string cval_name = "TimeDelta";
+ base::TimeDelta cval_value(base::TimeDelta::FromMicroseconds(5500));
+ base::CVal<base::TimeDelta> cval(cval_name, cval_value, "Description.");
+ base::CValManager* cvm = base::CValManager::GetInstance();
+ base::optional<std::string> result = cvm->GetValueAsPrettyString(cval_name);
+ EXPECT_TRUE(result);
+ EXPECT_EQ(*result, "5.5ms");
+}
+
+TEST(CValTest, RegisterAndPrintTimeDeltaSeconds) {
+ const std::string cval_name = "TimeDelta";
+ base::TimeDelta cval_value(base::TimeDelta::FromSeconds(50));
+ base::CVal<base::TimeDelta> cval(cval_name, cval_value, "Description.");
+ base::CValManager* cvm = base::CValManager::GetInstance();
+ base::optional<std::string> result = cvm->GetValueAsPrettyString(cval_name);
+ EXPECT_TRUE(result);
+ EXPECT_EQ(*result, "50.0s");
+}
+
+TEST(CValTest, RegisterAndPrintTimeDeltaSecondsSingleDigit) {
+ const std::string cval_name = "TimeDelta";
+ base::TimeDelta cval_value(base::TimeDelta::FromSeconds(5));
+ base::CVal<base::TimeDelta> cval(cval_name, cval_value, "Description.");
+ base::CValManager* cvm = base::CValManager::GetInstance();
+ base::optional<std::string> result = cvm->GetValueAsPrettyString(cval_name);
+ EXPECT_TRUE(result);
+ EXPECT_EQ(*result, "5.0s");
+}
+
+TEST(CValTest, RegisterAndPrintTimeDeltaSecondsFraction) {
+ const std::string cval_name = "TimeDelta";
+ base::TimeDelta cval_value(base::TimeDelta::FromMilliseconds(5500));
+ base::CVal<base::TimeDelta> cval(cval_name, cval_value, "Description.");
+ base::CValManager* cvm = base::CValManager::GetInstance();
+ base::optional<std::string> result = cvm->GetValueAsPrettyString(cval_name);
+ EXPECT_TRUE(result);
+ EXPECT_EQ(*result, "5.5s");
+}
+
+TEST(CValTest, RegisterAndPrintTimeDeltaMinutes) {
+ const std::string cval_name = "TimeDelta";
+ base::TimeDelta cval_value(base::TimeDelta::FromMinutes(50));
+ base::CVal<base::TimeDelta> cval(cval_name, cval_value, "Description.");
+ base::CValManager* cvm = base::CValManager::GetInstance();
+ base::optional<std::string> result = cvm->GetValueAsPrettyString(cval_name);
+ EXPECT_TRUE(result);
+ EXPECT_EQ(*result, "50:00m");
+}
+
+TEST(CValTest, RegisterAndPrintTimeDeltaMinutesSingleDigit) {
+ const std::string cval_name = "TimeDelta";
+ base::TimeDelta cval_value(base::TimeDelta::FromMinutes(5));
+ base::CVal<base::TimeDelta> cval(cval_name, cval_value, "Description.");
+ base::CValManager* cvm = base::CValManager::GetInstance();
+ base::optional<std::string> result = cvm->GetValueAsPrettyString(cval_name);
+ EXPECT_TRUE(result);
+ EXPECT_EQ(*result, "5:00m");
+}
+
+TEST(CValTest, RegisterAndPrintTimeDeltaMinutesAndSeconds) {
+ const std::string cval_name = "TimeDelta";
+ base::TimeDelta cval_value(base::TimeDelta::FromSeconds(92));
+ base::CVal<base::TimeDelta> cval(cval_name, cval_value, "Description.");
+ base::CValManager* cvm = base::CValManager::GetInstance();
+ base::optional<std::string> result = cvm->GetValueAsPrettyString(cval_name);
+ EXPECT_TRUE(result);
+ EXPECT_EQ(*result, "1:32m");
+}
+
+TEST(CValTest, RegisterAndPrintTimeDeltaHours) {
+ const std::string cval_name = "TimeDelta";
+ base::TimeDelta cval_value(base::TimeDelta::FromHours(50));
+ base::CVal<base::TimeDelta> cval(cval_name, cval_value, "Description.");
+ base::CValManager* cvm = base::CValManager::GetInstance();
+ base::optional<std::string> result = cvm->GetValueAsPrettyString(cval_name);
+ EXPECT_TRUE(result);
+ EXPECT_EQ(*result, "50:00:00h");
+}
+
+TEST(CValTest, RegisterAndPrintTimeDeltaHoursSingleDigit) {
+ const std::string cval_name = "TimeDelta";
+ base::TimeDelta cval_value(base::TimeDelta::FromHours(5));
+ base::CVal<base::TimeDelta> cval(cval_name, cval_value, "Description.");
+ base::CValManager* cvm = base::CValManager::GetInstance();
+ base::optional<std::string> result = cvm->GetValueAsPrettyString(cval_name);
+ EXPECT_TRUE(result);
+ EXPECT_EQ(*result, "5:00:00h");
+}
+
+TEST(CValTest, RegisterAndPrintTimeDeltaHoursAndMinutes) {
+ const std::string cval_name = "TimeDelta";
+ base::TimeDelta cval_value(base::TimeDelta::FromMinutes(92));
+ base::CVal<base::TimeDelta> cval(cval_name, cval_value, "Description.");
+ base::CValManager* cvm = base::CValManager::GetInstance();
+ base::optional<std::string> result = cvm->GetValueAsPrettyString(cval_name);
+ EXPECT_TRUE(result);
+ EXPECT_EQ(*result, "1:32:00h");
+}
+
+TEST(CValTest, RegisterAndPrintTimeDeltaHoursAndMinutesAndSeconds) {
+ const std::string cval_name = "TimeDelta";
+ base::TimeDelta cval_value(base::TimeDelta::FromSeconds(92 * 60 + 32));
+ base::CVal<base::TimeDelta> cval(cval_name, cval_value, "Description.");
+ base::CValManager* cvm = base::CValManager::GetInstance();
+ base::optional<std::string> result = cvm->GetValueAsPrettyString(cval_name);
+ EXPECT_TRUE(result);
+ EXPECT_EQ(*result, "1:32:32h");
+}
+
+TEST(CValTest, RegisterAndPrintTimeDeltaHoursAndSeconds) {
+ const std::string cval_name = "TimeDelta";
+ base::TimeDelta cval_value(base::TimeDelta::FromSeconds(60 * 60 + 32));
+ base::CVal<base::TimeDelta> cval(cval_name, cval_value, "Description.");
+ base::CValManager* cvm = base::CValManager::GetInstance();
+ base::optional<std::string> result = cvm->GetValueAsPrettyString(cval_name);
+ EXPECT_TRUE(result);
+ EXPECT_EQ(*result, "1:00:32h");
+}
+
+TEST(CValTest, RegisterAndPrintTimeDeltaNegativeMicroseconds) {
+ const std::string cval_name = "TimeDelta";
+ base::TimeDelta cval_value(base::TimeDelta::FromMicroseconds(-3));
+ base::CVal<base::TimeDelta> cval(cval_name, cval_value, "Description.");
+ base::CValManager* cvm = base::CValManager::GetInstance();
+ base::optional<std::string> result = cvm->GetValueAsPrettyString(cval_name);
+ EXPECT_TRUE(result);
+ EXPECT_EQ(*result, "-3us");
+}
+
+TEST(CValTest, RegisterAndPrintTimeDeltaNegativeMilliseconds) {
+ const std::string cval_name = "TimeDelta";
+ base::TimeDelta cval_value(base::TimeDelta::FromMilliseconds(-3));
+ base::CVal<base::TimeDelta> cval(cval_name, cval_value, "Description.");
+ base::CValManager* cvm = base::CValManager::GetInstance();
+ base::optional<std::string> result = cvm->GetValueAsPrettyString(cval_name);
+ EXPECT_TRUE(result);
+ EXPECT_EQ(*result, "-3.0ms");
+}
+
+TEST(CValTest, RegisterAndPrintTimeDeltaNegativeSeconds) {
+ const std::string cval_name = "TimeDelta";
+ base::TimeDelta cval_value(base::TimeDelta::FromSeconds(-3));
+ base::CVal<base::TimeDelta> cval(cval_name, cval_value, "Description.");
+ base::CValManager* cvm = base::CValManager::GetInstance();
+ base::optional<std::string> result = cvm->GetValueAsPrettyString(cval_name);
+ EXPECT_TRUE(result);
+ EXPECT_EQ(*result, "-3.0s");
+}
+
+TEST(CValTest, RegisterAndPrintTimeDeltaNegativeMinutes) {
+ const std::string cval_name = "TimeDelta";
+ base::TimeDelta cval_value(base::TimeDelta::FromMinutes(-3));
+ base::CVal<base::TimeDelta> cval(cval_name, cval_value, "Description.");
+ base::CValManager* cvm = base::CValManager::GetInstance();
+ base::optional<std::string> result = cvm->GetValueAsPrettyString(cval_name);
+ EXPECT_TRUE(result);
+ EXPECT_EQ(*result, "-3:00m");
+}
+
+TEST(CValTest, RegisterAndPrintTimeDeltaNegativeHours) {
+ const std::string cval_name = "TimeDelta";
+ base::TimeDelta cval_value(base::TimeDelta::FromHours(-3));
+ base::CVal<base::TimeDelta> cval(cval_name, cval_value, "Description.");
+ base::CValManager* cvm = base::CValManager::GetInstance();
+ base::optional<std::string> result = cvm->GetValueAsPrettyString(cval_name);
+ EXPECT_TRUE(result);
+ EXPECT_EQ(*result, "-3:00:00h");
+}
+
TEST(CValTest, RegisterAndPrintFloat) {
const std::string cval_name = "float";
const float cval_value = 3.14159f;
diff --git a/src/cobalt/base/deep_link_event.h b/src/cobalt/base/deep_link_event.h
new file mode 100644
index 0000000..5e3df4b
--- /dev/null
+++ b/src/cobalt/base/deep_link_event.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright 2016 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef COBALT_BASE_DEEP_LINK_EVENT_H_
+#define COBALT_BASE_DEEP_LINK_EVENT_H_
+
+#include <string>
+
+#include "base/compiler_specific.h"
+#include "cobalt/base/event.h"
+
+namespace base {
+
+class DeepLinkEvent : public Event {
+ public:
+ explicit DeepLinkEvent(const std::string& link) : link_(link) {}
+ const std::string& link() const { return link_; }
+
+ BASE_EVENT_SUBCLASS(DeepLinkEvent);
+
+ private:
+ std::string link_;
+};
+
+} // namespace base
+
+#endif // COBALT_BASE_DEEP_LINK_EVENT_H_
diff --git a/src/cobalt/base/init_cobalt.cc b/src/cobalt/base/init_cobalt.cc
index f9ed397..9cad4b4 100644
--- a/src/cobalt/base/init_cobalt.cc
+++ b/src/cobalt/base/init_cobalt.cc
@@ -16,6 +16,8 @@
#include "cobalt/base/init_cobalt.h"
+#include <string>
+
#include "base/at_exit.h"
#include "base/command_line.h"
#include "base/i18n/icu_util.h"
@@ -51,10 +53,15 @@
#endif
+base::LazyInstance<std::string> s_initial_deep_link = LAZY_INSTANCE_INITIALIZER;
+
} // namespace
-void InitCobalt(int argc, char* argv[]) {
+void InitCobalt(int argc, char* argv[], const char* link) {
CommandLine::Init(argc, argv);
+ if (link) {
+ s_initial_deep_link.Get() = link;
+ }
deprecated::PlatformDelegate::Init();
// Register a callback to be called during program termination.
@@ -74,4 +81,6 @@
LOG_IF(ERROR, !icu_initialized) << "ICU initialization failed.";
}
+const char* GetInitialDeepLink() { return s_initial_deep_link.Get().c_str(); }
+
} // namespace cobalt
diff --git a/src/cobalt/base/init_cobalt.h b/src/cobalt/base/init_cobalt.h
index 14aed0c..1ba9cdf 100644
--- a/src/cobalt/base/init_cobalt.h
+++ b/src/cobalt/base/init_cobalt.h
@@ -32,7 +32,10 @@
//
// ..RunSomeCode..
// }
-void InitCobalt(int argc, char* argv[]);
+void InitCobalt(int argc, char* argv[], const char* initial_deep_link);
+
+// Get the |initial_deep_link| string specified in |InitCobalt|.
+const char* GetInitialDeepLink();
} // namespace cobalt
diff --git a/src/cobalt/base/wrap_main.h b/src/cobalt/base/wrap_main.h
index 10aacce..193e379 100644
--- a/src/cobalt/base/wrap_main.h
+++ b/src/cobalt/base/wrap_main.h
@@ -42,7 +42,7 @@
typedef int (*MainFunction)(int argc, char** argv);
// A start-style function.
-typedef void (*StartFunction)(int argc, char** argv,
+typedef void (*StartFunction)(int argc, char** argv, const char* link,
const base::Closure& quit_closure);
// A function type that can be called at shutdown.
@@ -53,7 +53,7 @@
// No-operation function that can be passed into start_function if no start work
// is needed.
-void NoopStartFunction(int /*argc*/, char** /*argv*/,
+void NoopStartFunction(int /*argc*/, char** /*argv*/, const char* /*link*/,
const base::Closure& /*quit_closure*/) {}
// No-operation function that can be passed into event_function if no other
@@ -75,16 +75,16 @@
namespace wrap_main {
template <MainFunction main_function>
-int SimpleMain(int argc, char **argv) {
+int SimpleMain(int argc, char** argv) {
base::AtExitManager at_exit;
- InitCobalt(argc, argv);
+ InitCobalt(argc, argv, NULL);
return main_function(argc, argv);
}
template <StartFunction start_function, StopFunction stop_function>
-int BaseMain(int argc, char **argv) {
+int BaseMain(int argc, char** argv) {
base::AtExitManager at_exit;
- InitCobalt(argc, argv);
+ InitCobalt(argc, argv, NULL);
MessageLoopForUI message_loop;
base::PlatformThread::SetName("Main");
@@ -93,7 +93,7 @@
DCHECK(!message_loop.is_running());
base::RunLoop run_loop;
- start_function(argc, argv, run_loop.QuitClosure());
+ start_function(argc, argv, NULL, run_loop.QuitClosure());
run_loop.Run();
stop_function();
@@ -103,7 +103,7 @@
// Calls |main_function| at startup, creates an AtExitManager and calls
// InitCobalt, and terminates once it is completed.
#define COBALT_WRAP_SIMPLE_MAIN(main_function) \
- int main(int argc, char **argv) { \
+ int main(int argc, char** argv) { \
return ::cobalt::wrap_main::SimpleMain<main_function>(argc, argv); \
}
@@ -111,7 +111,7 @@
// terminates once the MessageLoop terminates, calling |stop_function| on the
// way out.
#define COBALT_WRAP_BASE_MAIN(start_function, stop_function) \
- int main(int argc, char **argv) { \
+ int main(int argc, char** argv) { \
return ::cobalt::wrap_main::BaseMain<start_function, stop_function>(argc, \
argv); \
}
diff --git a/src/cobalt/base/wrap_main_starboard.h b/src/cobalt/base/wrap_main_starboard.h
index 1a72bd7..dad3708 100644
--- a/src/cobalt/base/wrap_main_starboard.h
+++ b/src/cobalt/base/wrap_main_starboard.h
@@ -42,14 +42,14 @@
DCHECK(!g_at_exit);
g_at_exit = new base::AtExitManager();
- InitCobalt(data->argument_count, data->argument_values);
+ InitCobalt(data->argument_count, data->argument_values, data->link);
DCHECK(!g_loop);
g_loop = new MessageLoopForUI();
g_loop->set_thread_name("Main");
g_loop->Start();
- start_function(data->argument_count, data->argument_values,
+ start_function(data->argument_count, data->argument_values, data->link,
base::Bind(&SbSystemRequestStop, 0));
break;
}
@@ -78,7 +78,7 @@
template <MainFunction main_function>
int CobaltMainAddOns(int argc, char** argv) {
base::AtExitManager at_exit;
- cobalt::InitCobalt(argc, argv);
+ cobalt::InitCobalt(argc, argv, NULL);
return main_function(argc, argv);
}
diff --git a/src/cobalt/bindings/testing/get_opaque_root_test.cc b/src/cobalt/bindings/testing/get_opaque_root_test.cc
index ef72e1f..e60db42 100644
--- a/src/cobalt/bindings/testing/get_opaque_root_test.cc
+++ b/src/cobalt/bindings/testing/get_opaque_root_test.cc
@@ -24,8 +24,19 @@
namespace testing {
namespace {
-typedef InterfaceBindingsTest<GetOpaqueRootInterface>
- GetOpaqueRootInterfaceTest;
+class GetOpaqueRootInterfaceTest : public BindingsTestBase {
+ public:
+ GetOpaqueRootInterfaceTest()
+ : test_mock_(new ::testing::NiceMock<GetOpaqueRootInterface>()) {
+ global_environment_->Bind(
+ "test", make_scoped_refptr<GetOpaqueRootInterface>((test_mock_)));
+ }
+
+ GetOpaqueRootInterface& test_mock() { return *test_mock_.get(); }
+
+ private:
+ const scoped_refptr<GetOpaqueRootInterface> test_mock_;
+};
} // namespace
TEST_F(GetOpaqueRootInterfaceTest, CallsFunction) {
diff --git a/src/cobalt/browser/application.cc b/src/cobalt/browser/application.cc
index ac19432..27c9f1a 100644
--- a/src/cobalt/browser/application.cc
+++ b/src/cobalt/browser/application.cc
@@ -29,6 +29,8 @@
#include "build/build_config.h"
#include "cobalt/account/account_event.h"
#include "cobalt/base/cobalt_paths.h"
+#include "cobalt/base/deep_link_event.h"
+#include "cobalt/base/init_cobalt.h"
#include "cobalt/base/localized_strings.h"
#include "cobalt/base/user_log.h"
#include "cobalt/browser/switches.h"
@@ -290,6 +292,7 @@
BrowserModule::Options options;
options.web_module_options.name = "MainWebModule";
options.language = language;
+ options.initial_deep_link = GetInitialDeepLink();
options.network_module_options.preferred_language = language;
ApplyCommandLineSettingsToRendererOptions(&options.renderer_module_options);
diff --git a/src/cobalt/browser/browser_bindings.gyp b/src/cobalt/browser/browser_bindings.gyp
index 80049c1..cb9d50b 100644
--- a/src/cobalt/browser/browser_bindings.gyp
+++ b/src/cobalt/browser/browser_bindings.gyp
@@ -155,6 +155,7 @@
'../h5vcc/H5vccAudioConfigArray.idl',
'../h5vcc/H5vccCVal.idl',
'../h5vcc/H5vccCValKeyList.idl',
+ '../h5vcc/H5vccDeepLinkEventTarget.idl',
'../h5vcc/H5vccRuntime.idl',
'../h5vcc/H5vccRuntimeEventTarget.idl',
'../h5vcc/H5vccSettings.idl',
diff --git a/src/cobalt/browser/browser_module.cc b/src/cobalt/browser/browser_module.cc
index cd3c605..692ee5d 100644
--- a/src/cobalt/browser/browser_module.cc
+++ b/src/cobalt/browser/browser_module.cc
@@ -16,12 +16,16 @@
#include "cobalt/browser/browser_module.h"
+#include <vector>
+
#include "base/bind.h"
#include "base/command_line.h"
#include "base/debug/trace_event.h"
#include "base/logging.h"
#include "base/path_service.h"
#include "base/stl_util.h"
+#include "base/string_number_conversions.h"
+#include "base/string_split.h"
#include "cobalt/base/cobalt_paths.h"
#include "cobalt/base/source_location.h"
#include "cobalt/base/tokens.h"
@@ -53,6 +57,15 @@
"activated or not. While activated, input will constantly and randomly be "
"generated and passed directly into the main web module.";
+const char kSetMediaConfigCommand[] = "set_media_config";
+const char kSetMediaConfigCommandShortHelp[] =
+ "Sets media module configuration.";
+const char kSetMediaConfigCommandLongHelp[] =
+ "This can be called in the form of set_media_config('name=value'), where "
+ "name is a string and value is an int. Refer to the implementation of "
+ "MediaModule::SetConfiguration() on individual platform for settings "
+ "supported on the particular platform.";
+
#if defined(ENABLE_SCREENSHOT)
// Command to take a screenshot.
const char kScreenshotCommand[] = "screenshot";
@@ -134,6 +147,10 @@
kFuzzerToggleCommand,
base::Bind(&BrowserModule::OnFuzzerToggle, base::Unretained(this)),
kFuzzerToggleCommandShortHelp, kFuzzerToggleCommandLongHelp)),
+ ALLOW_THIS_IN_INITIALIZER_LIST(set_media_config_command_handler_(
+ kSetMediaConfigCommand,
+ base::Bind(&BrowserModule::OnSetMediaConfig, base::Unretained(this)),
+ kSetMediaConfigCommandShortHelp, kSetMediaConfigCommandLongHelp)),
#if defined(ENABLE_SCREENSHOT)
ALLOW_THIS_IN_INITIALIZER_LIST(screenshot_command_handler_(
kScreenshotCommand,
@@ -156,6 +173,7 @@
h5vcc_settings.network_module = &network_module_;
h5vcc_settings.account_manager = account_manager;
h5vcc_settings.event_dispatcher = system_window->event_dispatcher();
+ h5vcc_settings.initial_deep_link = options.initial_deep_link;
web_module_options_.injected_window_attributes["h5vcc"] =
base::Bind(&CreateH5VCC, h5vcc_settings);
@@ -330,6 +348,30 @@
}
}
+void BrowserModule::OnSetMediaConfig(const std::string& config) {
+ if (MessageLoop::current() != self_message_loop_) {
+ self_message_loop_->PostTask(
+ FROM_HERE,
+ base::Bind(&BrowserModule::OnSetMediaConfig, weak_this_, config));
+ return;
+ }
+
+ std::vector<std::string> tokens;
+ base::SplitString(config, '=', &tokens);
+
+ int value;
+ if (tokens.size() != 2 || !base::StringToInt(tokens[1], &value)) {
+ LOG(WARNING) << "Media configuration '" << config << "' is not in the"
+ << " form of '<string name>=<int value>'.";
+ return;
+ }
+ if (media_module_->SetConfiguration(tokens[0], value)) {
+ LOG(INFO) << "Successfully setting " << tokens[0] << " to " << value;
+ } else {
+ LOG(WARNING) << "Failed to set " << tokens[0] << " to " << value;
+ }
+}
+
void BrowserModule::OnDebugConsoleRenderTreeProduced(
const browser::WebModule::LayoutResults& layout_results) {
TRACE_EVENT0("cobalt::browser",
diff --git a/src/cobalt/browser/browser_module.h b/src/cobalt/browser/browser_module.h
index 742a4d3..df6da73 100644
--- a/src/cobalt/browser/browser_module.h
+++ b/src/cobalt/browser/browser_module.h
@@ -64,6 +64,7 @@
WebModule::Options web_module_options;
media::MediaModule::Options media_module_options;
std::string language;
+ std::string initial_deep_link;
base::Closure web_module_recreated_callback;
};
@@ -166,6 +167,10 @@
// Toggles the input fuzzer on/off. Ignores the parameter.
void OnFuzzerToggle(const std::string&);
+ // Use the config in the form of '<string name>=<int value>' to call
+ // MediaModule::SetConfiguration().
+ void OnSetMediaConfig(const std::string& config);
+
// Glue function to deal with the production of the debug console render tree,
// and will manage handing it off to the renderer.
void OnDebugConsoleRenderTreeProduced(
@@ -266,9 +271,12 @@
TraceManager trace_manager;
- // Command handler object for toggline the input fuzzer on/off.
+ // Command handler object for toggling the input fuzzer on/off.
base::ConsoleCommandManager::CommandHandler fuzzer_toggle_command_handler_;
+ // Command handler object for setting media module config.
+ base::ConsoleCommandManager::CommandHandler set_media_config_command_handler_;
+
#if defined(ENABLE_SCREENSHOT)
// Command handler object for screenshot command from the debug console.
base::ConsoleCommandManager::CommandHandler screenshot_command_handler_;
diff --git a/src/cobalt/browser/main.cc b/src/cobalt/browser/main.cc
index ef98aff..6b5fef2 100644
--- a/src/cobalt/browser/main.cc
+++ b/src/cobalt/browser/main.cc
@@ -27,7 +27,7 @@
cobalt::browser::Application* g_application = NULL;
-void StartApplication(int /*argc*/, char** /*argv*/,
+void StartApplication(int /*argc*/, char** /*argv*/, const char* /*link*/,
const base::Closure& quit_closure) {
DCHECK(!g_application);
g_application = cobalt::browser::CreateApplication(quit_closure).release();
diff --git a/src/cobalt/browser/snapshot_app_stats.cc b/src/cobalt/browser/snapshot_app_stats.cc
index 757e784..050914f 100644
--- a/src/cobalt/browser/snapshot_app_stats.cc
+++ b/src/cobalt/browser/snapshot_app_stats.cc
@@ -130,7 +130,7 @@
cobalt::browser::Application* g_application = NULL;
base::Thread* g_snapshot_thread = NULL;
-void StartApplication(int /*argc*/, char* /*argv*/ [],
+void StartApplication(int /*argc*/, char* /*argv*/ [], const char* /*link*/,
const base::Closure& quit_closure) {
logging::SetMinLogLevel(100);
diff --git a/src/cobalt/browser/starboard/event_handler.cc b/src/cobalt/browser/starboard/event_handler.cc
index 00808d7..be5e494 100644
--- a/src/cobalt/browser/starboard/event_handler.cc
+++ b/src/cobalt/browser/starboard/event_handler.cc
@@ -18,6 +18,7 @@
#include "base/logging.h"
#include "base/memory/scoped_ptr.h"
+#include "cobalt/base/deep_link_event.h"
#include "cobalt/network/network_event.h"
#include "cobalt/system_window/application_event.h"
#include "cobalt/system_window/starboard/system_window.h"
@@ -65,6 +66,9 @@
} else if (starboard_event->type == kSbEventTypeNetworkDisconnect) {
cobalt_event.reset(
new network::NetworkEvent(network::NetworkEvent::kDisconnection));
+ } else if (starboard_event->type == kSbEventTypeLink) {
+ const char* link = static_cast<const char*>(starboard_event->data);
+ cobalt_event.reset(new base::DeepLinkEvent(link));
}
// Dispatch the Cobalt event, if created.
diff --git a/src/cobalt/build/build.id b/src/cobalt/build/build.id
index 0e34392..eb49ee4 100644
--- a/src/cobalt/build/build.id
+++ b/src/cobalt/build/build.id
@@ -1 +1 @@
-11130
\ No newline at end of file
+11337
\ No newline at end of file
diff --git a/src/cobalt/dom/Window.idl b/src/cobalt/dom/Window.idl
index 3094309..b6a3e20 100644
--- a/src/cobalt/dom/Window.idl
+++ b/src/cobalt/dom/Window.idl
@@ -25,6 +25,7 @@
[Unforgeable] readonly attribute Document document;
[PutForwards=href, Unforgeable] readonly attribute Location location;
readonly attribute History history;
+ void close();
// other browsing contexts
[Replaceable] readonly attribute Window frames;
diff --git a/src/cobalt/dom/html_script_element.cc b/src/cobalt/dom/html_script_element.cc
index fcfdf35..b94ee93 100644
--- a/src/cobalt/dom/html_script_element.cc
+++ b/src/cobalt/dom/html_script_element.cc
@@ -53,7 +53,8 @@
load_option_(0),
inline_script_location_(GetSourceLocationName(), 1, 1),
is_sync_load_successful_(false),
- prevent_garbage_collection_count_(0) {
+ prevent_garbage_collection_count_(0),
+ should_execute_(true) {
DCHECK(document->html_element_context()->script_runner());
}
@@ -260,12 +261,9 @@
base::Unretained(this)));
if (is_sync_load_successful_) {
- html_element_context()->script_runner()->Execute(
- content_, base::SourceLocation(url_.spec(), 1, 1));
-
- // If the script is from an external file, fire a simple event named
- // load at the script element.
- DispatchEvent(new Event(base::Tokens::load()));
+ PreventGarbageCollection();
+ ExecuteExternal();
+ AllowGarbageCollection();
} else {
// Executing the script block must just consist of firing a simple event
// named error at the element.
@@ -497,6 +495,16 @@
void HTMLScriptElement::Execute(const std::string& content,
const base::SourceLocation& script_location,
bool is_external) {
+ // If should_execute_ is set to false for whatever reason, then we
+ // immediately exit.
+ // When inserted using the document.write() method, script elements execute
+ // (typically synchronously), but when inserted using innerHTML and
+ // outerHTML attributes, they do not execute at all.
+ // https://www.w3.org/TR/html5/scripting-1.html#the-script-element.
+ if (!should_execute_) {
+ return;
+ }
+
TRACE_EVENT0("cobalt::dom", "HTMLScriptElement::Execute()");
// Since error is already handled, it is guaranteed the load is successful.
diff --git a/src/cobalt/dom/html_script_element.h b/src/cobalt/dom/html_script_element.h
index 17ab6d4..aa523db 100644
--- a/src/cobalt/dom/html_script_element.h
+++ b/src/cobalt/dom/html_script_element.h
@@ -62,6 +62,10 @@
SetAttributeEventListener(base::Tokens::readystatechange(), event_listener);
}
+ void set_should_execute(bool should_execute) {
+ should_execute_ = should_execute;
+ }
+
// Custom, not in any spec.
//
// From Node.
@@ -133,6 +137,9 @@
std::string content_;
// Active requests disabling garbage collection.
int prevent_garbage_collection_count_;
+
+ // Whether or not the script should execute at all.
+ bool should_execute_;
};
} // namespace dom
diff --git a/src/cobalt/dom/parser.h b/src/cobalt/dom/parser.h
index 554643e..3bf7392 100644
--- a/src/cobalt/dom/parser.h
+++ b/src/cobalt/dom/parser.h
@@ -45,7 +45,8 @@
virtual ~Parser() {}
// Synchronous parsing interfaces.
//
- // Parses an HTML document and returns the created Document.
+ // Parses an HTML document and returns the created Document. No
+ // script elements within the HTML document will be executed.
virtual scoped_refptr<Document> ParseDocument(
const std::string& input, HTMLElementContext* html_element_context,
const base::SourceLocation& input_location) = 0;
@@ -56,7 +57,8 @@
const base::SourceLocation& input_location) = 0;
// Parses an HTML input and inserts new nodes in document under parent_node
- // before reference_node.
+ // before reference_node. No script elements within the HTML document will
+ // be executed.
virtual void ParseDocumentFragment(
const std::string& input, const scoped_refptr<Document>& document,
const scoped_refptr<Node>& parent_node,
@@ -74,7 +76,8 @@
// Asynchronous parsing interfaces.
//
// Parses an HTML document asynchronously, returns the decoder that can be
- // used in the parsing.
+ // used in the parsing. Script elements in the HTML document will be
+ // executed.
virtual scoped_ptr<loader::Decoder> ParseDocumentAsync(
const scoped_refptr<Document>& document,
const base::SourceLocation& input_location) = 0;
diff --git a/src/cobalt/dom/window.cc b/src/cobalt/dom/window.cc
index 8a57e10..3e23ed9 100644
--- a/src/cobalt/dom/window.cc
+++ b/src/cobalt/dom/window.cc
@@ -39,6 +39,9 @@
#include "cobalt/dom/storage.h"
#include "cobalt/dom/window_timers.h"
#include "cobalt/script/javascript_engine.h"
+#if defined(OS_STARBOARD)
+#include "starboard/system.h"
+#endif
namespace cobalt {
namespace dom {
@@ -135,6 +138,15 @@
const scoped_refptr<History>& Window::history() const { return history_; }
+// https://www.w3.org/TR/html5/browsers.html#dom-window-close
+void Window::Close() {
+#if defined(OS_STARBOARD)
+ SbSystemRequestStop(0);
+#else
+ LOG(WARNING) << "window.close is not supported on this platform.";
+#endif
+}
+
const scoped_refptr<Navigator>& Window::navigator() const { return navigator_; }
scoped_refptr<cssom::CSSStyleDeclaration> Window::GetComputedStyle(
diff --git a/src/cobalt/dom/window.h b/src/cobalt/dom/window.h
index 6b2e776..8240112 100644
--- a/src/cobalt/dom/window.h
+++ b/src/cobalt/dom/window.h
@@ -116,6 +116,7 @@
const scoped_refptr<Document>& document() const;
const scoped_refptr<Location>& location() const;
const scoped_refptr<History>& history() const;
+ void Close();
scoped_refptr<Window> frames() { return this; }
unsigned int length() { return 0; }
diff --git a/src/cobalt/dom_parser/html_decoder.cc b/src/cobalt/dom_parser/html_decoder.cc
index ddda365..f0b5585 100644
--- a/src/cobalt/dom_parser/html_decoder.cc
+++ b/src/cobalt/dom_parser/html_decoder.cc
@@ -30,12 +30,14 @@
const scoped_refptr<dom::Node>& reference_node,
const int dom_max_element_depth, const base::SourceLocation& input_location,
const base::Closure& done_callback,
- const base::Callback<void(const std::string&)>& error_callback)
+ const base::Callback<void(const std::string&)>& error_callback,
+ const bool should_run_scripts)
: libxml_html_parser_wrapper_(new LibxmlHTMLParserWrapper(
document, parent_node, reference_node, dom_max_element_depth,
- input_location, error_callback)),
+ input_location, error_callback, should_run_scripts)),
document_(document),
- done_callback_(done_callback) {}
+ done_callback_(done_callback),
+ should_run_scripts_(should_run_scripts) {}
HTMLDecoder::~HTMLDecoder() {}
diff --git a/src/cobalt/dom_parser/html_decoder.h b/src/cobalt/dom_parser/html_decoder.h
index 853fd47..db142e7 100644
--- a/src/cobalt/dom_parser/html_decoder.h
+++ b/src/cobalt/dom_parser/html_decoder.h
@@ -49,7 +49,8 @@
const int dom_max_element_depth,
const base::SourceLocation& input_location,
const base::Closure& done_callback,
- const base::Callback<void(const std::string&)>& error_callback);
+ const base::Callback<void(const std::string&)>& error_callback,
+ const bool should_run_scripts);
~HTMLDecoder();
@@ -68,6 +69,8 @@
base::ThreadChecker thread_checker_;
const base::Closure done_callback_;
+ const bool should_run_scripts_;
+
DISALLOW_COPY_AND_ASSIGN(HTMLDecoder);
};
diff --git a/src/cobalt/dom_parser/html_decoder_test.cc b/src/cobalt/dom_parser/html_decoder_test.cc
index ab5f6a1..92736ea 100644
--- a/src/cobalt/dom_parser/html_decoder_test.cc
+++ b/src/cobalt/dom_parser/html_decoder_test.cc
@@ -82,7 +82,8 @@
html_decoder_.reset(new HTMLDecoder(
document_, document_, NULL, kDOMMaxElementDepth, source_location_,
base::Closure(), base::Bind(&MockErrorCallback::Run,
- base::Unretained(&mock_error_callback_))));
+ base::Unretained(&mock_error_callback_)),
+ true));
html_decoder_->DecodeChunk(input.c_str(), input.length());
html_decoder_->Finish();
@@ -104,7 +105,8 @@
html_decoder_.reset(new HTMLDecoder(
document_, document_, NULL, kDOMMaxElementDepth, source_location_,
base::Closure(), base::Bind(&MockErrorCallback::Run,
- base::Unretained(&mock_error_callback_))));
+ base::Unretained(&mock_error_callback_)),
+ true));
html_decoder_->DecodeChunk(reinterpret_cast<char*>(temp), sizeof(temp));
html_decoder_->Finish();
@@ -122,7 +124,8 @@
html_decoder_.reset(new HTMLDecoder(
document_, document_, NULL, kDOMMaxElementDepth, source_location_,
base::Closure(), base::Bind(&MockErrorCallback::Run,
- base::Unretained(&mock_error_callback_))));
+ base::Unretained(&mock_error_callback_)),
+ true));
html_decoder_->DecodeChunk(input.c_str(), input.length());
html_decoder_->Finish();
@@ -140,7 +143,8 @@
html_decoder_.reset(new HTMLDecoder(
document_, document_, NULL, kDOMMaxElementDepth, source_location_,
base::Closure(), base::Bind(&MockErrorCallback::Run,
- base::Unretained(&mock_error_callback_))));
+ base::Unretained(&mock_error_callback_)),
+ true));
html_decoder_->DecodeChunk(input.c_str(), input.length());
html_decoder_->Finish();
@@ -158,7 +162,8 @@
html_decoder_.reset(new HTMLDecoder(
document_, document_, NULL, kDOMMaxElementDepth, source_location_,
base::Closure(), base::Bind(&MockErrorCallback::Run,
- base::Unretained(&mock_error_callback_))));
+ base::Unretained(&mock_error_callback_)),
+ true));
html_decoder_->DecodeChunk(input.c_str(), input.length());
html_decoder_->Finish();
@@ -176,7 +181,8 @@
html_decoder_.reset(new HTMLDecoder(
document_, document_, NULL, kDOMMaxElementDepth, source_location_,
base::Closure(), base::Bind(&MockErrorCallback::Run,
- base::Unretained(&mock_error_callback_))));
+ base::Unretained(&mock_error_callback_)),
+ true));
html_decoder_->DecodeChunk(input.c_str(), input.length());
html_decoder_->Finish();
@@ -199,7 +205,8 @@
html_decoder_.reset(new HTMLDecoder(
document_, root_, NULL, kDOMMaxElementDepth, source_location_,
base::Closure(), base::Bind(&MockErrorCallback::Run,
- base::Unretained(&mock_error_callback_))));
+ base::Unretained(&mock_error_callback_)),
+ true));
html_decoder_->DecodeChunk(input.c_str(), input.length());
html_decoder_->Finish();
@@ -214,7 +221,8 @@
html_decoder_.reset(new HTMLDecoder(
document_, root_, NULL, kDOMMaxElementDepth, source_location_,
base::Closure(), base::Bind(&MockErrorCallback::Run,
- base::Unretained(&mock_error_callback_))));
+ base::Unretained(&mock_error_callback_)),
+ true));
html_decoder_->DecodeChunk(input.c_str(), input.length());
html_decoder_->Finish();
@@ -238,7 +246,8 @@
html_decoder_.reset(new HTMLDecoder(
document_, root_, NULL, kDOMMaxElementDepth, source_location_,
base::Closure(), base::Bind(&MockErrorCallback::Run,
- base::Unretained(&mock_error_callback_))));
+ base::Unretained(&mock_error_callback_)),
+ true));
html_decoder_->DecodeChunk(input.c_str(), input.length());
html_decoder_->Finish();
@@ -258,7 +267,8 @@
html_decoder_.reset(new HTMLDecoder(
document_, root_, NULL, kDOMMaxElementDepth, source_location_,
base::Closure(), base::Bind(&MockErrorCallback::Run,
- base::Unretained(&mock_error_callback_))));
+ base::Unretained(&mock_error_callback_)),
+ true));
html_decoder_->DecodeChunk(input.c_str(), input.length());
html_decoder_->Finish();
@@ -276,7 +286,8 @@
html_decoder_.reset(new HTMLDecoder(
document_, root_, NULL, kDOMMaxElementDepth, source_location_,
base::Closure(), base::Bind(&MockErrorCallback::Run,
- base::Unretained(&mock_error_callback_))));
+ base::Unretained(&mock_error_callback_)),
+ true));
html_decoder_->DecodeChunk(input.c_str(), input.length());
html_decoder_->Finish();
@@ -295,7 +306,8 @@
html_decoder_.reset(new HTMLDecoder(
document_, root_, NULL, kDOMMaxElementDepth, source_location_,
base::Closure(), base::Bind(&MockErrorCallback::Run,
- base::Unretained(&mock_error_callback_))));
+ base::Unretained(&mock_error_callback_)),
+ true));
html_decoder_->DecodeChunk(reinterpret_cast<char*>(temp), sizeof(temp));
html_decoder_->Finish();
@@ -308,7 +320,8 @@
html_decoder_.reset(new HTMLDecoder(
document_, root_, NULL, kDOMMaxElementDepth, source_location_,
base::Closure(), base::Bind(&MockErrorCallback::Run,
- base::Unretained(&mock_error_callback_))));
+ base::Unretained(&mock_error_callback_)),
+ true));
html_decoder_->DecodeChunk(input.c_str(), input.length());
html_decoder_->Finish();
@@ -335,7 +348,8 @@
html_decoder_.reset(new HTMLDecoder(
document_, root_, NULL, kDOMMaxElementDepth, source_location_,
base::Closure(), base::Bind(&MockErrorCallback::Run,
- base::Unretained(&mock_error_callback_))));
+ base::Unretained(&mock_error_callback_)),
+ true));
html_decoder_->DecodeChunk(input.c_str(), input.length());
html_decoder_->Finish();
@@ -354,7 +368,8 @@
html_decoder_.reset(new HTMLDecoder(
document_, root_, NULL, kDOMMaxElementDepth, source_location_,
base::Closure(), base::Bind(&MockErrorCallback::Run,
- base::Unretained(&mock_error_callback_))));
+ base::Unretained(&mock_error_callback_)),
+ true));
html_decoder_->DecodeChunk(input.c_str(), input.length());
html_decoder_->Finish();
@@ -376,7 +391,8 @@
html_decoder_.reset(new HTMLDecoder(
document_, root_, NULL, kDOMMaxElementDepth, source_location_,
base::Closure(), base::Bind(&MockErrorCallback::Run,
- base::Unretained(&mock_error_callback_))));
+ base::Unretained(&mock_error_callback_)),
+ true));
html_decoder_->DecodeChunk(input.c_str(), input.length());
html_decoder_->Finish();
@@ -402,7 +418,8 @@
html_decoder_.reset(new HTMLDecoder(
document_, root_, NULL, kDOMMaxElementDepth, source_location_,
base::Closure(), base::Bind(&MockErrorCallback::Run,
- base::Unretained(&mock_error_callback_))));
+ base::Unretained(&mock_error_callback_)),
+ true));
html_decoder_->DecodeChunk(input.c_str(), input.length());
html_decoder_->Finish();
@@ -420,7 +437,8 @@
html_decoder_.reset(new HTMLDecoder(
document_, root_, NULL, kDOMMaxElementDepth, source_location_,
base::Closure(), base::Bind(&MockErrorCallback::Run,
- base::Unretained(&mock_error_callback_))));
+ base::Unretained(&mock_error_callback_)),
+ true));
html_decoder_->DecodeChunk(input.c_str(), input.length());
html_decoder_->Finish();
@@ -434,7 +452,8 @@
html_decoder_.reset(new HTMLDecoder(
document_, root_, NULL, kDOMMaxElementDepth, source_location_,
base::Closure(), base::Bind(&MockErrorCallback::Run,
- base::Unretained(&mock_error_callback_))));
+ base::Unretained(&mock_error_callback_)),
+ true));
html_decoder_->DecodeChunk(input.c_str(), input.length());
html_decoder_->Finish();
@@ -457,7 +476,8 @@
html_decoder_.reset(new HTMLDecoder(
document_, document_, NULL, kDOMMaxElementDepth, source_location_,
base::Closure(), base::Bind(&MockErrorCallback::Run,
- base::Unretained(&mock_error_callback_))));
+ base::Unretained(&mock_error_callback_)),
+ true));
html_decoder_->DecodeChunk(input.c_str(), input.length());
html_decoder_->Finish();
diff --git a/src/cobalt/dom_parser/libxml_html_parser_wrapper.cc b/src/cobalt/dom_parser/libxml_html_parser_wrapper.cc
index a50c295..e65ef8f 100644
--- a/src/cobalt/dom_parser/libxml_html_parser_wrapper.cc
+++ b/src/cobalt/dom_parser/libxml_html_parser_wrapper.cc
@@ -18,6 +18,8 @@
#include "base/basictypes.h"
#include "base/string_util.h"
+#include "cobalt/dom/element.h"
+#include "cobalt/dom/html_script_element.h"
namespace cobalt {
namespace dom_parser {
@@ -89,6 +91,17 @@
if (!IsFullDocument() && (name == "html" || name == "body")) {
return;
}
+
+ // If the top if the node stack is an html script element, then set its
+ // should_execute_ field to be our should_run_scripts_ field.
+ DCHECK(!node_stack().empty());
+ if (name == "script") {
+ scoped_refptr<dom::HTMLScriptElement> html_script_element =
+ node_stack().top()->AsElement()->AsHTMLElement()->AsHTMLScriptElement();
+ DCHECK(html_script_element);
+ html_script_element->set_should_execute(should_run_scripts_);
+ }
+
LibxmlParserWrapper::OnEndElement(name);
}
diff --git a/src/cobalt/dom_parser/libxml_html_parser_wrapper.h b/src/cobalt/dom_parser/libxml_html_parser_wrapper.h
index f553818..7114443 100644
--- a/src/cobalt/dom_parser/libxml_html_parser_wrapper.h
+++ b/src/cobalt/dom_parser/libxml_html_parser_wrapper.h
@@ -40,11 +40,13 @@
const scoped_refptr<dom::Node>& reference_node,
const int dom_max_element_depth,
const base::SourceLocation& input_location,
- const base::Callback<void(const std::string&)>& error_callback)
+ const base::Callback<void(const std::string&)>& error_callback,
+ const bool should_run_scripts)
: LibxmlParserWrapper(document, parent_node, reference_node,
dom_max_element_depth, input_location,
error_callback),
- html_parser_context_(NULL) {
+ html_parser_context_(NULL),
+ should_run_scripts_(should_run_scripts) {
DCHECK(!document->IsXMLDocument());
}
~LibxmlHTMLParserWrapper() OVERRIDE;
@@ -61,6 +63,8 @@
htmlParserCtxtPtr html_parser_context_;
+ const bool should_run_scripts_;
+
DISALLOW_COPY_AND_ASSIGN(LibxmlHTMLParserWrapper);
};
diff --git a/src/cobalt/dom_parser/parser.cc b/src/cobalt/dom_parser/parser.cc
index 507c187..5be05a6 100644
--- a/src/cobalt/dom_parser/parser.cc
+++ b/src/cobalt/dom_parser/parser.cc
@@ -32,7 +32,8 @@
scoped_refptr<dom::Document> document =
new dom::Document(html_element_context, dom::Document::Options());
HTMLDecoder html_decoder(document, document, NULL, dom_max_element_depth_,
- input_location, base::Closure(), error_callback_);
+ input_location, base::Closure(), error_callback_,
+ false);
html_decoder.DecodeChunk(input.c_str(), input.length());
html_decoder.Finish();
return document;
@@ -60,7 +61,7 @@
const base::SourceLocation& input_location) {
HTMLDecoder html_decoder(document, parent_node, reference_node,
dom_max_element_depth_, input_location,
- base::Closure(), error_callback_);
+ base::Closure(), error_callback_, false);
html_decoder.DecodeChunk(input.c_str(), input.length());
html_decoder.Finish();
}
@@ -84,7 +85,7 @@
const base::SourceLocation& input_location) {
return scoped_ptr<loader::Decoder>(
new HTMLDecoder(document, document, NULL, dom_max_element_depth_,
- input_location, base::Closure(), error_callback_));
+ input_location, base::Closure(), error_callback_, true));
}
scoped_ptr<loader::Decoder> Parser::ParseXMLDocumentAsync(
diff --git a/src/cobalt/h5vcc/H5vccDeepLinkEventTarget.idl b/src/cobalt/h5vcc/H5vccDeepLinkEventTarget.idl
new file mode 100644
index 0000000..8f823a9
--- /dev/null
+++ b/src/cobalt/h5vcc/H5vccDeepLinkEventTarget.idl
@@ -0,0 +1,25 @@
+/*
+ * Copyright 2016 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Custom interface to dispatch deep link events.
+// Modeled after Chrome's runtime onMessage target (and similar):
+// https://developer.chrome.com/apps/runtime#event-onMessage
+
+interface H5vccDeepLinkEventTarget {
+ void addListener(H5vccDeepLinkEventCallback callback);
+};
+
+callback H5vccDeepLinkEventCallback = void(DOMString link);
diff --git a/src/cobalt/h5vcc/H5vccRuntime.idl b/src/cobalt/h5vcc/H5vccRuntime.idl
index 18b8acb..02ed8ad 100644
--- a/src/cobalt/h5vcc/H5vccRuntime.idl
+++ b/src/cobalt/h5vcc/H5vccRuntime.idl
@@ -15,6 +15,8 @@
*/
interface H5vccRuntime {
+ readonly attribute DOMString initialDeepLink;
+ readonly attribute H5vccDeepLinkEventTarget onDeepLink;
readonly attribute H5vccRuntimeEventTarget onPause;
readonly attribute H5vccRuntimeEventTarget onResume;
};
diff --git a/src/cobalt/h5vcc/h5vcc.cc b/src/cobalt/h5vcc/h5vcc.cc
index b0cf530..9792fcb 100644
--- a/src/cobalt/h5vcc/h5vcc.cc
+++ b/src/cobalt/h5vcc/h5vcc.cc
@@ -23,7 +23,8 @@
account_info_ = new H5vccAccountInfo(settings.account_manager);
audio_config_array_ = new H5vccAudioConfigArray();
c_val_ = new H5vccCVal();
- runtime_ = new H5vccRuntime(settings.event_dispatcher);
+ runtime_ =
+ new H5vccRuntime(settings.event_dispatcher, settings.initial_deep_link);
settings_ = new H5vccSettings(settings.media_module);
storage_ = new H5vccStorage(settings.network_module);
system_ = new H5vccSystem();
diff --git a/src/cobalt/h5vcc/h5vcc.gyp b/src/cobalt/h5vcc/h5vcc.gyp
index 835c4f9..c208fd0 100644
--- a/src/cobalt/h5vcc/h5vcc.gyp
+++ b/src/cobalt/h5vcc/h5vcc.gyp
@@ -39,6 +39,9 @@
'h5vcc_c_val.h',
'h5vcc_c_val_key_list.cc',
'h5vcc_c_val_key_list.h',
+ 'h5vcc_deep_link_event_target.cc',
+ 'h5vcc_deep_link_event_target.h',
+ 'h5vcc_event_listener_container.h',
'h5vcc_runtime.cc',
'h5vcc_runtime.h',
'h5vcc_runtime_event_target.cc',
diff --git a/src/cobalt/h5vcc/h5vcc.h b/src/cobalt/h5vcc/h5vcc.h
index e8395b4..369cad3 100644
--- a/src/cobalt/h5vcc/h5vcc.h
+++ b/src/cobalt/h5vcc/h5vcc.h
@@ -17,6 +17,8 @@
#ifndef COBALT_H5VCC_H5VCC_H_
#define COBALT_H5VCC_H5VCC_H_
+#include <string>
+
#include "cobalt/base/event_dispatcher.h"
#include "cobalt/h5vcc/h5vcc_account_info.h"
#include "cobalt/h5vcc/h5vcc_audio_config_array.h"
@@ -42,6 +44,7 @@
network::NetworkModule* network_module;
account::AccountManager* account_manager;
base::EventDispatcher* event_dispatcher;
+ std::string initial_deep_link;
};
explicit H5vcc(const Settings& config);
diff --git a/src/cobalt/h5vcc/h5vcc_deep_link_event_target.cc b/src/cobalt/h5vcc/h5vcc_deep_link_event_target.cc
new file mode 100644
index 0000000..697688d
--- /dev/null
+++ b/src/cobalt/h5vcc/h5vcc_deep_link_event_target.cc
@@ -0,0 +1,40 @@
+/*
+ * Copyright 2016 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "cobalt/h5vcc/h5vcc_deep_link_event_target.h"
+
+namespace cobalt {
+namespace h5vcc {
+
+namespace {
+const std::string& OnGetArgument(const std::string& link) { return link; }
+} // namespace
+
+H5vccDeepLinkEventTarget::H5vccDeepLinkEventTarget()
+ : ALLOW_THIS_IN_INITIALIZER_LIST(listeners_(this)) {}
+
+void H5vccDeepLinkEventTarget::AddListener(
+ const H5vccDeepLinkEventTarget::H5vccDeepLinkEventCallbackHolder&
+ callback_holder) {
+ listeners_.AddListener(callback_holder);
+}
+
+void H5vccDeepLinkEventTarget::DispatchEvent(const std::string& link) {
+ listeners_.DispatchEvent(base::Bind(OnGetArgument, link));
+}
+
+} // namespace h5vcc
+} // namespace cobalt
diff --git a/src/cobalt/h5vcc/h5vcc_deep_link_event_target.h b/src/cobalt/h5vcc/h5vcc_deep_link_event_target.h
new file mode 100644
index 0000000..4a6b706
--- /dev/null
+++ b/src/cobalt/h5vcc/h5vcc_deep_link_event_target.h
@@ -0,0 +1,69 @@
+/*
+ * Copyright 2016 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef COBALT_H5VCC_H5VCC_DEEP_LINK_EVENT_TARGET_H_
+#define COBALT_H5VCC_H5VCC_DEEP_LINK_EVENT_TARGET_H_
+
+#include <string>
+#include <vector>
+
+#include "base/callback.h"
+#include "base/location.h"
+#include "base/message_loop_proxy.h"
+#include "base/synchronization/lock.h"
+#include "cobalt/h5vcc/h5vcc_event_listener_container.h"
+#include "cobalt/script/callback_function.h"
+#include "cobalt/script/script_object.h"
+#include "cobalt/script/wrappable.h"
+
+namespace cobalt {
+namespace h5vcc {
+
+// This class implements the onDeepLink attribute of the h5vcc.runtime protocol,
+// modeled after the events in Chrome's runtime extension, e.g.
+// https://developer.chrome.com/apps/runtime#event-onMessage
+
+class H5vccDeepLinkEventTarget : public script::Wrappable {
+ public:
+ // Type for JavaScript event callback.
+ typedef script::CallbackFunction<void(const std::string&)>
+ H5vccDeepLinkEventCallback;
+ typedef script::ScriptObject<H5vccDeepLinkEventCallback>
+ H5vccDeepLinkEventCallbackHolder;
+
+ H5vccDeepLinkEventTarget();
+
+ // Called from JavaScript to register an event listener callback.
+ // May be called from any thread.
+ void AddListener(const H5vccDeepLinkEventCallbackHolder& callback_holder);
+
+ // Dispatches an event to the registered listeners.
+ // May be called from any thread.
+ void DispatchEvent(const std::string& link);
+
+ DEFINE_WRAPPABLE_TYPE(H5vccDeepLinkEventTarget);
+
+ private:
+ H5vccEventListenerContainer<const std::string&, H5vccDeepLinkEventCallback>
+ listeners_;
+
+ DISALLOW_COPY_AND_ASSIGN(H5vccDeepLinkEventTarget);
+};
+
+} // namespace h5vcc
+} // namespace cobalt
+
+#endif // COBALT_H5VCC_H5VCC_DEEP_LINK_EVENT_TARGET_H_
diff --git a/src/cobalt/h5vcc/h5vcc_event_listener_container.h b/src/cobalt/h5vcc/h5vcc_event_listener_container.h
new file mode 100644
index 0000000..6f91143
--- /dev/null
+++ b/src/cobalt/h5vcc/h5vcc_event_listener_container.h
@@ -0,0 +1,121 @@
+/*
+ * Copyright 2016 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef COBALT_H5VCC_H5VCC_EVENT_LISTENER_CONTAINER_H_
+#define COBALT_H5VCC_H5VCC_EVENT_LISTENER_CONTAINER_H_
+
+#include <string>
+#include <vector>
+
+#include "base/callback.h"
+#include "base/location.h"
+#include "base/message_loop_proxy.h"
+#include "base/synchronization/lock.h"
+#include "cobalt/script/callback_function.h"
+#include "cobalt/script/script_object.h"
+#include "cobalt/script/wrappable.h"
+
+namespace cobalt {
+namespace h5vcc {
+
+// Template class to implement a container of event listeners where the
+// listener callback can take an argument of any type, including none (void).
+// Callback type must be specified in addition to callback argument type,
+// as we cannot typedef a callback taking a void argument.
+template <class CallbackArgType, class CallbackType>
+class H5vccEventListenerContainer {
+ public:
+ typedef script::ScriptObject<CallbackType> CallbackHolderType;
+
+ // Type for a callback that returns the value of the argument to be passed
+ // to the callback for each listener.
+ typedef base::Callback<CallbackArgType()> GetArgumentCallback;
+
+ // Type for a listener.
+ // We store the message loop from which the listener was registered,
+ // so we can run the callback on the same loop.
+ struct Listener {
+ Listener(script::Wrappable* owner, const CallbackHolderType& cb)
+ : callback(owner, cb),
+ message_loop(base::MessageLoopProxy::current()) {}
+
+ // Notifies listener. Must be called on the same message loop the
+ // listener registered its callback from.
+ void Notify(GetArgumentCallback on_notify) {
+ DCHECK_EQ(base::MessageLoopProxy::current(), message_loop);
+ CallbackArgType arg = on_notify.Run();
+ callback.value().Run(arg);
+ }
+
+ typename CallbackHolderType::Reference callback;
+ scoped_refptr<base::MessageLoopProxy> message_loop;
+ };
+
+ explicit H5vccEventListenerContainer(script::Wrappable* owner)
+ : owner_(owner) {}
+
+ ~H5vccEventListenerContainer() {
+ // Delete all registered listeners.
+ for (typename ListenerVector::const_iterator it = listeners_.begin();
+ it != listeners_.end(); ++it) {
+ delete *it;
+ }
+ }
+
+ // Called from JavaScript to register an event listener. May be called from
+ // any thread, and event notification will be called on the same thread.
+ void AddListener(const CallbackHolderType& callback_holder) {
+ base::AutoLock auto_lock(lock_);
+ listeners_.push_back(new Listener(owner_, callback_holder));
+ }
+
+ // Dispatches an event to the registered listeners. May be called from any
+ // thread, and the callbacks will be invoked on the same thread each listener
+ // was registered on. |get_argument_callback| must be a function that
+ // returns the argument value for this event.
+ void DispatchEvent(GetArgumentCallback get_argument_callback) {
+ base::AutoLock auto_lock(lock_);
+ for (typename ListenerVector::iterator it = listeners_.begin();
+ it != listeners_.end(); ++it) {
+ Listener* listener = *it;
+ listener->message_loop->PostTask(
+ FROM_HERE, base::Bind(&Listener::Notify, base::Unretained(listener),
+ get_argument_callback));
+ }
+ }
+
+ private:
+ typedef std::vector<Listener*> ListenerVector;
+
+ script::Wrappable* owner_;
+ ListenerVector listeners_;
+ base::Lock lock_;
+};
+
+// Explicit template specialization for the no callback argument case, where
+// we don't need to call the |GetArgumentCallback| callback.
+template <>
+inline void
+ H5vccEventListenerContainer<void, script::CallbackFunction<void()> >::
+ Listener::Notify(GetArgumentCallback) {
+ DCHECK_EQ(base::MessageLoopProxy::current(), message_loop);
+ callback.value().Run();
+}
+
+} // namespace h5vcc
+} // namespace cobalt
+
+#endif // COBALT_H5VCC_H5VCC_EVENT_LISTENER_CONTAINER_H_
diff --git a/src/cobalt/h5vcc/h5vcc_runtime.cc b/src/cobalt/h5vcc/h5vcc_runtime.cc
index 09acb30..8b0f871 100644
--- a/src/cobalt/h5vcc/h5vcc_runtime.cc
+++ b/src/cobalt/h5vcc/h5vcc_runtime.cc
@@ -14,14 +14,18 @@
* limitations under the License.
*/
+#include "cobalt/base/deep_link_event.h"
#include "cobalt/base/polymorphic_downcast.h"
#include "cobalt/h5vcc/h5vcc_runtime.h"
#include "cobalt/system_window/application_event.h"
namespace cobalt {
namespace h5vcc {
-H5vccRuntime::H5vccRuntime(base::EventDispatcher* event_dispatcher)
+H5vccRuntime::H5vccRuntime(base::EventDispatcher* event_dispatcher,
+ const std::string& initial_deep_link)
: event_dispatcher_(event_dispatcher) {
+ initial_deep_link_ = initial_deep_link;
+ on_deep_link_ = new H5vccDeepLinkEventTarget;
on_pause_ = new H5vccRuntimeEventTarget;
on_resume_ = new H5vccRuntimeEventTarget;
@@ -30,11 +34,26 @@
base::Bind(&H5vccRuntime::OnApplicationEvent, base::Unretained(this));
event_dispatcher_->AddEventCallback(system_window::ApplicationEvent::TypeId(),
application_event_callback_);
+ deep_link_event_callback_ =
+ base::Bind(&H5vccRuntime::OnDeepLinkEvent, base::Unretained(this));
+ event_dispatcher_->AddEventCallback(base::DeepLinkEvent::TypeId(),
+ deep_link_event_callback_);
}
H5vccRuntime::~H5vccRuntime() {
event_dispatcher_->RemoveEventCallback(
system_window::ApplicationEvent::TypeId(), application_event_callback_);
+ event_dispatcher_->RemoveEventCallback(base::DeepLinkEvent::TypeId(),
+ deep_link_event_callback_);
+}
+
+const std::string& H5vccRuntime::initial_deep_link() const {
+ return initial_deep_link_;
+}
+
+const scoped_refptr<H5vccDeepLinkEventTarget>& H5vccRuntime::on_deep_link()
+ const {
+ return on_deep_link_;
}
const scoped_refptr<H5vccRuntimeEventTarget>& H5vccRuntime::on_pause() const {
@@ -56,5 +75,12 @@
on_resume()->DispatchEvent();
}
}
+
+void H5vccRuntime::OnDeepLinkEvent(const base::Event* event) {
+ const base::DeepLinkEvent* deep_link_event =
+ base::polymorphic_downcast<const base::DeepLinkEvent*>(event);
+ DLOG(INFO) << "Got deep link event: " << deep_link_event->link();
+ on_deep_link()->DispatchEvent(deep_link_event->link());
+}
} // namespace h5vcc
} // namespace cobalt
diff --git a/src/cobalt/h5vcc/h5vcc_runtime.h b/src/cobalt/h5vcc/h5vcc_runtime.h
index 8c14def..e51e87b 100644
--- a/src/cobalt/h5vcc/h5vcc_runtime.h
+++ b/src/cobalt/h5vcc/h5vcc_runtime.h
@@ -17,7 +17,10 @@
#ifndef COBALT_H5VCC_H5VCC_RUNTIME_H_
#define COBALT_H5VCC_H5VCC_RUNTIME_H_
+#include <string>
+
#include "cobalt/base/event_dispatcher.h"
+#include "cobalt/h5vcc/h5vcc_deep_link_event_target.h"
#include "cobalt/h5vcc/h5vcc_runtime_event_target.h"
#include "cobalt/script/wrappable.h"
@@ -26,26 +29,33 @@
class H5vccRuntime : public script::Wrappable {
public:
- explicit H5vccRuntime(base::EventDispatcher* event_dispatcher);
+ explicit H5vccRuntime(base::EventDispatcher* event_dispatcher,
+ const std::string& initial_deep_link);
~H5vccRuntime();
+ const std::string& initial_deep_link() const;
+ const scoped_refptr<H5vccDeepLinkEventTarget>& on_deep_link() const;
const scoped_refptr<H5vccRuntimeEventTarget>& on_pause() const;
const scoped_refptr<H5vccRuntimeEventTarget>& on_resume() const;
DEFINE_WRAPPABLE_TYPE(H5vccRuntime);
private:
- // Called by the event dispatcher to handle an application event.
+ // Called by the event dispatcher to handle various event types.
void OnApplicationEvent(const base::Event* event);
+ void OnDeepLinkEvent(const base::Event* event);
+ std::string initial_deep_link_;
+ scoped_refptr<H5vccDeepLinkEventTarget> on_deep_link_;
scoped_refptr<H5vccRuntimeEventTarget> on_pause_;
scoped_refptr<H5vccRuntimeEventTarget> on_resume_;
// Non-owned reference used to receive application event callbacks.
base::EventDispatcher* event_dispatcher_;
- // Application event callback.
+ // Event callbacks.
base::EventCallback application_event_callback_;
+ base::EventCallback deep_link_event_callback_;
DISALLOW_COPY_AND_ASSIGN(H5vccRuntime);
};
diff --git a/src/cobalt/h5vcc/h5vcc_runtime_event_target.cc b/src/cobalt/h5vcc/h5vcc_runtime_event_target.cc
index 32902e0..4174201 100644
--- a/src/cobalt/h5vcc/h5vcc_runtime_event_target.cc
+++ b/src/cobalt/h5vcc/h5vcc_runtime_event_target.cc
@@ -16,43 +16,23 @@
#include "cobalt/h5vcc/h5vcc_runtime_event_target.h"
-#include "base/location.h"
-
namespace cobalt {
namespace h5vcc {
-H5vccRuntimeEventTarget::H5vccRuntimeEventTarget() {}
+namespace {
+void OnGetArgument() {}
+} // namespace
-H5vccRuntimeEventTarget::~H5vccRuntimeEventTarget() {
- // Delete all registered listeners.
- for (ListenerVector::const_iterator it = listeners_.begin();
- it != listeners_.end(); ++it) {
- delete *it;
- }
-}
+H5vccRuntimeEventTarget::H5vccRuntimeEventTarget()
+ : ALLOW_THIS_IN_INITIALIZER_LIST(listeners_(this)) {}
void H5vccRuntimeEventTarget::AddListener(
- const H5vccRuntimeEventTarget::H5vccRuntimeEventCallbackHolder& callback) {
- base::AutoLock auto_lock(lock_);
- listeners_.push_back(new ListenerInfo(this, callback));
+ const H5vccRuntimeEventCallbackHolder& callback_holder) {
+ listeners_.AddListener(callback_holder);
}
void H5vccRuntimeEventTarget::DispatchEvent() {
- base::AutoLock auto_lock(lock_);
-
- for (ListenerVector::const_iterator it = listeners_.begin();
- it != listeners_.end(); ++it) {
- const ListenerInfo* listener = *it;
- listener->message_loop->PostTask(
- FROM_HERE,
- base::Bind(&H5vccRuntimeEventTarget::NotifyListener, this, listener));
- }
-}
-
-void H5vccRuntimeEventTarget::NotifyListener(
- const H5vccRuntimeEventTarget::ListenerInfo* listener) {
- DCHECK_EQ(base::MessageLoopProxy::current(), listener->message_loop);
- listener->callback.value().Run();
+ listeners_.DispatchEvent(base::Bind(OnGetArgument));
}
} // namespace h5vcc
diff --git a/src/cobalt/h5vcc/h5vcc_runtime_event_target.h b/src/cobalt/h5vcc/h5vcc_runtime_event_target.h
index 344623e..fc2b491 100644
--- a/src/cobalt/h5vcc/h5vcc_runtime_event_target.h
+++ b/src/cobalt/h5vcc/h5vcc_runtime_event_target.h
@@ -22,6 +22,7 @@
#include "base/callback.h"
#include "base/message_loop_proxy.h"
#include "base/synchronization/lock.h"
+#include "cobalt/h5vcc/h5vcc_event_listener_container.h"
#include "cobalt/script/callback_function.h"
#include "cobalt/script/script_object.h"
#include "cobalt/script/wrappable.h"
@@ -40,21 +41,7 @@
typedef script::ScriptObject<H5vccRuntimeEventCallback>
H5vccRuntimeEventCallbackHolder;
- // Type for listener info.
- // We store the message loop from which the listener was registered,
- // so we can run the callback on the same loop.
- struct ListenerInfo {
- ListenerInfo(H5vccRuntimeEventTarget* const pause_event,
- const H5vccRuntimeEventCallbackHolder& cb)
- : callback(pause_event, cb),
- message_loop(base::MessageLoopProxy::current()) {}
-
- H5vccRuntimeEventCallbackHolder::Reference callback;
- scoped_refptr<base::MessageLoopProxy> message_loop;
- };
-
H5vccRuntimeEventTarget();
- ~H5vccRuntimeEventTarget();
// Called from JavaScript to register an event listener callback.
// May be called from any thread.
@@ -67,14 +54,7 @@
DEFINE_WRAPPABLE_TYPE(H5vccRuntimeEventTarget);
private:
- typedef std::vector<ListenerInfo*> ListenerVector;
-
- // Notifies a particular listener. Must be called on the same message loop the
- // listener registered its callback from.
- void NotifyListener(const ListenerInfo* listener);
-
- ListenerVector listeners_;
- base::Lock lock_;
+ H5vccEventListenerContainer<void, H5vccRuntimeEventCallback> listeners_;
DISALLOW_COPY_AND_ASSIGN(H5vccRuntimeEventTarget);
};
diff --git a/src/cobalt/layout_tests/testdata/css3-background/14-2-1-background-positioning-area-is-smaller-than-image-size.html b/src/cobalt/layout_tests/testdata/css3-background/14-2-1-background-positioning-area-is-smaller-than-image-size.html
index 53de4b8..d727d74 100644
--- a/src/cobalt/layout_tests/testdata/css3-background/14-2-1-background-positioning-area-is-smaller-than-image-size.html
+++ b/src/cobalt/layout_tests/testdata/css3-background/14-2-1-background-positioning-area-is-smaller-than-image-size.html
@@ -20,7 +20,7 @@
}
var image = new Image();
- var image_name = 'legend-sprite-ps3.png';
+ var image_name = 'legend-sprite.png';
image.onload = function() {
var cobalt = document.getElementById('image');
diff --git a/src/cobalt/layout_tests/testdata/css3-background/legend-sprite.png b/src/cobalt/layout_tests/testdata/css3-background/legend-sprite.png
new file mode 100644
index 0000000..f566171
--- /dev/null
+++ b/src/cobalt/layout_tests/testdata/css3-background/legend-sprite.png
Binary files differ
diff --git a/src/cobalt/network/cookie_jar_impl.cc b/src/cobalt/network/cookie_jar_impl.cc
index 5ad5205..6e573de 100644
--- a/src/cobalt/network/cookie_jar_impl.cc
+++ b/src/cobalt/network/cookie_jar_impl.cc
@@ -18,7 +18,6 @@
#include "base/bind.h"
#include "base/synchronization/waitable_event.h"
-#include "base/threading/thread.h"
namespace cobalt {
namespace network {
@@ -27,10 +26,10 @@
class CookiesGetter {
public:
- CookiesGetter(const GURL& origin, net::CookieStore* cookie_store)
- : getter_thread_("CookiesGetter"), event_(true, false) {
- getter_thread_.Start();
- getter_thread_.message_loop()->PostTask(
+ CookiesGetter(const GURL& origin, net::CookieStore* cookie_store,
+ MessageLoop* get_cookies_message_loop)
+ : event_(true, false) {
+ get_cookies_message_loop->PostTask(
FROM_HERE, base::Bind(&net::CookieStore::GetCookiesWithOptionsAsync,
cookie_store, origin, net::CookieOptions(),
base::Bind(&CookiesGetter::CompletionCallback,
@@ -49,19 +48,20 @@
}
std::string cookies_;
- base::Thread getter_thread_;
base::WaitableEvent event_;
};
} // namespace
CookieJarImpl::CookieJarImpl(net::CookieStore* cookie_store)
- : cookie_store_(cookie_store) {
+ : get_cookies_thread_("CookiesGetter"), cookie_store_(cookie_store) {
DCHECK(cookie_store_);
+ get_cookies_thread_.Start();
}
std::string CookieJarImpl::GetCookies(const GURL& origin) {
- CookiesGetter cookies_getter(origin, cookie_store_);
+ CookiesGetter cookies_getter(
+ origin, cookie_store_, get_cookies_thread_.message_loop());
return cookies_getter.WaitForCookies();
}
diff --git a/src/cobalt/network/cookie_jar_impl.h b/src/cobalt/network/cookie_jar_impl.h
index 9d68e39..6c87a3f 100644
--- a/src/cobalt/network/cookie_jar_impl.h
+++ b/src/cobalt/network/cookie_jar_impl.h
@@ -20,6 +20,7 @@
#include <string>
#include "base/compiler_specific.h"
+#include "base/threading/thread.h"
#include "cobalt/network_bridge/cookie_jar.h"
#include "net/cookies/cookie_store.h"
@@ -34,6 +35,11 @@
void SetCookie(const GURL& origin, const std::string& cookie_line) OVERRIDE;
private:
+ // We use a dedicated thread for making GetCookiesWithOptionsAsync() calls in
+ // order to workaround GetCookiesWithOptionsAsync()'s default behavior of
+ // PostTask()ing the completion callback to the message loop that the
+ // GetCookiesWithOptionsAsync() call was made from.
+ base::Thread get_cookies_thread_;
net::CookieStore* cookie_store_;
DISALLOW_COPY_AND_ASSIGN(CookieJarImpl);
diff --git a/src/cobalt/renderer/backend/egl/texture_data_pbo.cc b/src/cobalt/renderer/backend/egl/texture_data_pbo.cc
index edc0e40..86fc108 100644
--- a/src/cobalt/renderer/backend/egl/texture_data_pbo.cc
+++ b/src/cobalt/renderer/backend/egl/texture_data_pbo.cc
@@ -32,7 +32,7 @@
TextureDataPBO::TextureDataPBO(ResourceContext* resource_context,
const math::Size& size, GLenum format)
: resource_context_(resource_context), size_(size), format_(format) {
- data_size_ = GetPitchInBytes() * size_.height();
+ data_size_ = static_cast<int64>(GetPitchInBytes()) * size_.height();
resource_context_->RunSynchronouslyWithinResourceContext(
base::Bind(&TextureDataPBO::InitAndMapPBO, base::Unretained(this)));
@@ -57,7 +57,7 @@
GL_PIXEL_UNPACK_BUFFER, 0, data_size_, GL_MAP_WRITE_BIT |
GL_MAP_INVALIDATE_BUFFER_BIT |
GL_MAP_UNSYNCHRONIZED_BIT));
- DCHECK(mapped_data_);
+ CHECK(mapped_data_);
DCHECK_EQ(GL_NO_ERROR, glGetError());
GL_CALL(glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0));
}
diff --git a/src/cobalt/renderer/backend/egl/texture_data_pbo.h b/src/cobalt/renderer/backend/egl/texture_data_pbo.h
index 56754ea..d99ca54 100644
--- a/src/cobalt/renderer/backend/egl/texture_data_pbo.h
+++ b/src/cobalt/renderer/backend/egl/texture_data_pbo.h
@@ -63,7 +63,7 @@
math::Size size_;
GLenum format_;
GLuint pixel_buffer_;
- int data_size_;
+ int64 data_size_;
GLubyte* mapped_data_;
};
diff --git a/src/cobalt/renderer/sandbox/renderer_sandbox_main.cc b/src/cobalt/renderer/sandbox/renderer_sandbox_main.cc
index 3fddb14..60e72e6 100644
--- a/src/cobalt/renderer/sandbox/renderer_sandbox_main.cc
+++ b/src/cobalt/renderer/sandbox/renderer_sandbox_main.cc
@@ -80,7 +80,7 @@
RendererSandbox* g_renderer_sandbox = NULL;
-void StartApplication(int /*argc*/, char** /*argv*/,
+void StartApplication(int /*argc*/, char** /*argv*/, const char* /*link*/,
const base::Closure& quit_closure) {
DCHECK(!g_renderer_sandbox);
g_renderer_sandbox = new RendererSandbox();
diff --git a/src/cobalt/script/exception_message.cc b/src/cobalt/script/exception_message.cc
index 73ac903..939b6b1 100644
--- a/src/cobalt/script/exception_message.cc
+++ b/src/cobalt/script/exception_message.cc
@@ -40,7 +40,7 @@
{kConvertToEnumFailed, kTypeError, "Failed to convert JS value to enum."},
{kStringifierProblem, kTypeError, "Stringifier problem."},
{kNotFunctionValue, kTypeError, "Value is not a function."},
- {kInvalidNumberOfArguments, kRangeError, "Invalid number of arguments."},
+ {kInvalidNumberOfArguments, kTypeError, "Invalid number of arguments."},
{kNotUnionType, kTypeError, "Value is not a member of the union type."},
{kOutsideBounds, kRangeError, "Offset is outside the object's bounds."},
{kInvalidLength, kRangeError, "Invalid length."},
diff --git a/src/cobalt/script/mozjs/mozjs_engine.cc b/src/cobalt/script/mozjs/mozjs_engine.cc
index b4d16ec..1b79cf7 100644
--- a/src/cobalt/script/mozjs/mozjs_engine.cc
+++ b/src/cobalt/script/mozjs/mozjs_engine.cc
@@ -28,8 +28,18 @@
namespace {
// After this many bytes have been allocated, the garbage collector will run.
const uint32_t kGarbageCollectionThresholdBytes = 8 * 1024 * 1024;
+
+JSBool CheckAccessStub(JSContext*, JS::Handle<JSObject*>, JS::Handle<jsid>,
+ JSAccessMode, JS::MutableHandle<JS::Value>) {
+ return true;
}
+JSSecurityCallbacks security_callbacks = {
+ CheckAccessStub,
+ MozjsGlobalEnvironment::CheckEval
+};
+} // namespace
+
MozjsEngine::MozjsEngine() {
// TODO: Investigate the benefit of helper threads and things like
// parallel compilation.
@@ -39,6 +49,8 @@
JS_SetRuntimePrivate(runtime_, this);
+ JS_SetSecurityCallbacks(runtime_, &security_callbacks);
+
// Use incremental garbage collection.
JS_SetGCParameter(runtime_, JSGC_MODE, JSGC_MODE_INCREMENTAL);
diff --git a/src/cobalt/script/mozjs/mozjs_global_environment.cc b/src/cobalt/script/mozjs/mozjs_global_environment.cc
index bf2648c..25fa34b 100644
--- a/src/cobalt/script/mozjs/mozjs_global_environment.cc
+++ b/src/cobalt/script/mozjs/mozjs_global_environment.cc
@@ -227,8 +227,10 @@
MozjsExceptionState exception_state(context_);
FromJSValue(context_, result_value, kNoConversionFlags, &exception_state,
out_result_utf8);
- } else {
+ } else if (last_error_message_) {
*out_result_utf8 = *last_error_message_;
+ } else {
+ DLOG(ERROR) << "Script execution failed.";
}
}
JS_RestoreExceptionState(context_, previous_exception_state);
diff --git a/src/cobalt/script/mozjs/mozjs_global_environment.h b/src/cobalt/script/mozjs/mozjs_global_environment.h
index a774cb2..54f75de 100644
--- a/src/cobalt/script/mozjs/mozjs_global_environment.h
+++ b/src/cobalt/script/mozjs/mozjs_global_environment.h
@@ -128,17 +128,17 @@
static MozjsGlobalEnvironment* GetFromContext(JSContext* context);
+ // This will be called every time an attempt is made to use eval() and
+ // friends. If it returns false, then the ReportErrorHandler will be fired
+ // with an error that eval() is disabled.
+ static JSBool CheckEval(JSContext* context);
+
protected:
static void ReportErrorHandler(JSContext* context, const char* message,
JSErrorReport* report);
static void TraceFunction(JSTracer* trace, void* data);
- // This will be called every time an attempt is made to use eval() and
- // friends. If it returns false, then the ReportErrorHandler will be fired
- // with an error that eval() is disabled.
- static JSBool CheckEval(JSContext* context);
-
// Helper struct to ensure the context is destroyed in the correct order
// relative to the MozjsGlobalEnvironment's other members.
struct ContextDestructor {
diff --git a/src/cobalt/storage/savegame_thread.cc b/src/cobalt/storage/savegame_thread.cc
index 423e52f..a36cf48 100644
--- a/src/cobalt/storage/savegame_thread.cc
+++ b/src/cobalt/storage/savegame_thread.cc
@@ -26,7 +26,8 @@
SavegameThread::SavegameThread(const Savegame::Options& options)
: options_(options),
initialized_(true /* manual reset */, false /* initially signalled */),
- thread_(new base::Thread("Savegame I/O")) {
+ thread_(new base::Thread("Savegame I/O")),
+ num_consecutive_flush_failures_(0) {
TRACE_EVENT0("cobalt::storage", __FUNCTION__);
thread_->Start();
thread_->message_loop()->PostTask(
@@ -88,7 +89,15 @@
DCHECK_EQ(thread_->message_loop(), MessageLoop::current());
if (raw_bytes_ptr->size() > 0) {
bool ret = savegame_->Write(*raw_bytes_ptr);
- DCHECK(ret);
+ if (ret) {
+ num_consecutive_flush_failures_ = 0;
+ } else {
+ DLOG(ERROR) << "Save failed.";
+ const int kMaxConsecutiveFlushFailures = 2;
+ DCHECK_LT(++num_consecutive_flush_failures_,
+ kMaxConsecutiveFlushFailures);
+ return;
+ }
}
if (!on_flush_complete.is_null()) {
diff --git a/src/cobalt/storage/savegame_thread.h b/src/cobalt/storage/savegame_thread.h
index 1f9b90f..1ffbd77 100644
--- a/src/cobalt/storage/savegame_thread.h
+++ b/src/cobalt/storage/savegame_thread.h
@@ -52,7 +52,7 @@
// I/O thread.
void ShutdownOnIOThread();
- // runs on the I/O thread to write the database to the savegame's persistent
+ // Runs on the I/O thread to write the database to the savegame's persistent
// storage.
void FlushOnIOThread(scoped_ptr<Savegame::ByteVector> raw_bytes_ptr,
const base::Closure& on_flush_complete);
@@ -74,6 +74,11 @@
// Interface to platform-specific savegame data.
scoped_ptr<Savegame> savegame_;
+
+ // How many flush failures have occurred since the last successful flush.
+ // Flushes (storage writes) may sometimes fail, but we want to make sure
+ // they're not consistently failing.
+ int num_consecutive_flush_failures_;
};
} // namespace storage
diff --git a/src/cobalt/version.h b/src/cobalt/version.h
index 28e8c13..7c390aa 100644
--- a/src/cobalt/version.h
+++ b/src/cobalt/version.h
@@ -17,6 +17,6 @@
#define COBALT_VERSION_H_
// Cobalt release number.
-#define COBALT_VERSION "2"
+#define COBALT_VERSION "3"
#endif // COBALT_VERSION_H_
diff --git a/src/net/tools/dump_cache/url_to_filename_encoder.cc b/src/net/tools/dump_cache/url_to_filename_encoder.cc
new file mode 100644
index 0000000..e928ee9
--- /dev/null
+++ b/src/net/tools/dump_cache/url_to_filename_encoder.cc
@@ -0,0 +1,292 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <stdlib.h>
+
+#include "base/logging.h"
+#include "base/string_util.h"
+#include "net/base/net_util.h"
+#include "net/tools/dump_cache/url_to_filename_encoder.h"
+
+using std::string;
+
+namespace {
+
+// Returns 1 if buf is prefixed by "num_digits" of hex digits
+// Teturns 0 otherwise.
+// The function checks for '\0' for string termination.
+int HexDigitsPrefix(const char* buf, int num_digits) {
+ for (int i = 0; i < num_digits; i++) {
+ if (!IsHexDigit(buf[i]))
+ return 0; // This also detects end of string as '\0' is not xdigit.
+ }
+ return 1;
+}
+
+#if defined(WIN32) || defined(__LB_XB1__) || defined(__LB_XB360__)
+#define strtoull _strtoui64
+#endif
+
+// A simple parser for long long values. Returns the parsed value if a
+// valid integer is found; else returns deflt
+// UInt64 and Int64 cannot handle decimal numbers with leading 0s.
+uint64 ParseLeadingHex64Value(const char *str, uint64 deflt) {
+ char *error = NULL;
+ const uint64 value = strtoull(str, &error, 16);
+ return (error == str) ? deflt : value;
+}
+
+}
+
+namespace net {
+
+// The escape character choice is made here -- all code and tests in this
+// directory are based off of this constant. However, our testdata
+// has tons of dependencies on this, so it cannot be changed without
+// re-running those tests and fixing them.
+const char UrlToFilenameEncoder::kEscapeChar = ',';
+const char UrlToFilenameEncoder::kTruncationChar = '-';
+const size_t UrlToFilenameEncoder::kMaximumSubdirectoryLength = 128;
+
+void UrlToFilenameEncoder::AppendSegment(string* segment, string* dest) {
+ CHECK(!segment->empty());
+ if ((*segment == ".") || (*segment == "..")) {
+ dest->append(1, kEscapeChar);
+ dest->append(*segment);
+ segment->clear();
+ } else {
+ size_t segment_size = segment->size();
+ if (segment_size > kMaximumSubdirectoryLength) {
+ // We need to inject ",-" at the end of the segment to signify that
+ // we are inserting an artificial '/'. This means we have to chop
+ // off at least two characters to make room.
+ segment_size = kMaximumSubdirectoryLength - 2;
+
+ // But we don't want to break up an escape sequence that happens to lie at
+ // the end. Escape sequences are at most 2 characters.
+ if ((*segment)[segment_size - 1] == kEscapeChar) {
+ segment_size -= 1;
+ } else if ((*segment)[segment_size - 2] == kEscapeChar) {
+ segment_size -= 2;
+ }
+ dest->append(segment->data(), segment_size);
+ dest->append(1, kEscapeChar);
+ dest->append(1, kTruncationChar);
+ segment->erase(0, segment_size);
+
+ // At this point, if we had segment_size=3, and segment="abcd",
+ // then after this erase, we will have written "abc,-" and set segment="d"
+ } else {
+ dest->append(*segment);
+ segment->clear();
+ }
+ }
+}
+
+void UrlToFilenameEncoder::EncodeSegment(const string& filename_prefix,
+ const string& escaped_ending,
+ char dir_separator,
+ string* encoded_filename) {
+ string filename_ending = UrlUtilities::Unescape(escaped_ending);
+
+ char encoded[3];
+ int encoded_len;
+ string segment;
+
+ // TODO(jmarantz): This code would be a bit simpler if we disallowed
+ // Instaweb allowing filename_prefix to not end in "/". We could
+ // then change the is routine to just take one input string.
+ size_t start_of_segment = filename_prefix.find_last_of(dir_separator);
+ if (start_of_segment == string::npos) {
+ segment = filename_prefix;
+ } else {
+ segment = filename_prefix.substr(start_of_segment + 1);
+ *encoded_filename = filename_prefix.substr(0, start_of_segment + 1);
+ }
+
+ size_t index = 0;
+ // Special case the first / to avoid adding a leading kEscapeChar.
+ if (!filename_ending.empty() && (filename_ending[0] == dir_separator)) {
+ encoded_filename->append(segment);
+ segment.clear();
+ encoded_filename->append(1, dir_separator);
+ ++index;
+ }
+
+ for (; index < filename_ending.length(); ++index) {
+ unsigned char ch = static_cast<unsigned char>(filename_ending[index]);
+
+ // Note: instead of outputing an empty segment, we let the second slash
+ // be escaped below.
+ if ((ch == dir_separator) && !segment.empty()) {
+ AppendSegment(&segment, encoded_filename);
+ encoded_filename->append(1, dir_separator);
+ segment.clear();
+ } else {
+ // After removing unsafe chars the only safe ones are _.=+- and alphanums.
+ if ((ch == '_') || (ch == '.') || (ch == '=') || (ch == '+') ||
+ (ch == '-') || (('0' <= ch) && (ch <= '9')) ||
+ (('A' <= ch) && (ch <= 'Z')) || (('a' <= ch) && (ch <= 'z'))) {
+ encoded[0] = ch;
+ encoded_len = 1;
+ } else {
+ encoded[0] = kEscapeChar;
+ encoded[1] = ch / 16;
+ encoded[1] += (encoded[1] >= 10) ? 'A' - 10 : '0';
+ encoded[2] = ch % 16;
+ encoded[2] += (encoded[2] >= 10) ? 'A' - 10 : '0';
+ encoded_len = 3;
+ }
+ segment.append(encoded, encoded_len);
+
+ // If segment is too big, we must chop it into chunks.
+ if (segment.size() > kMaximumSubdirectoryLength) {
+ AppendSegment(&segment, encoded_filename);
+ encoded_filename->append(1, dir_separator);
+ }
+ }
+ }
+
+ // Append "," to the leaf filename so the leaf can also be a branch., e.g.
+ // allow http://a/b/c and http://a/b/c/d to co-exist as files "/a/b/c," and
+ // /a/b/c/d". So we will rename the "d" here to "d,". If doing that pushed
+ // us over the 128 char limit, then we will need to append "/" and the
+ // remaining chars.
+ segment += kEscapeChar;
+ AppendSegment(&segment, encoded_filename);
+ if (!segment.empty()) {
+ // The last overflow segment is special, because we appended in
+ // kEscapeChar above. We won't need to check it again for size
+ // or further escaping.
+ encoded_filename->append(1, dir_separator);
+ encoded_filename->append(segment);
+ }
+}
+
+// Note: this decoder is not the exact inverse of the EncodeSegment above,
+// because it does not take into account a prefix.
+bool UrlToFilenameEncoder::Decode(const string& encoded_filename,
+ char dir_separator,
+ string* decoded_url) {
+ enum State {
+ kStart,
+ kEscape,
+ kFirstDigit,
+ kTruncate,
+ kEscapeDot
+ };
+ State state = kStart;
+ char hex_buffer[3];
+ hex_buffer[2] = '\0';
+ for (size_t i = 0; i < encoded_filename.size(); ++i) {
+ char ch = encoded_filename[i];
+ switch (state) {
+ case kStart:
+ if (ch == kEscapeChar) {
+ state = kEscape;
+ } else if (ch == dir_separator) {
+ decoded_url->append(1, '/'); // URLs only use '/' not '\\'
+ } else {
+ decoded_url->append(1, ch);
+ }
+ break;
+ case kEscape:
+ if (HexDigitsPrefix(&ch, 1) == 1) {
+ hex_buffer[0] = ch;
+ state = kFirstDigit;
+ } else if (ch == kTruncationChar) {
+ state = kTruncate;
+ } else if (ch == '.') {
+ decoded_url->append(1, '.');
+ state = kEscapeDot; // Look for at most one more dot.
+ } else if (ch == dir_separator) {
+ // Consider url "//x". This was once encoded to "/,/x,".
+ // This code is what skips the first Escape.
+ decoded_url->append(1, '/'); // URLs only use '/' not '\\'
+ state = kStart;
+ } else {
+ return false;
+ }
+ break;
+ case kFirstDigit:
+ if (HexDigitsPrefix(&ch, 1) == 1) {
+ hex_buffer[1] = ch;
+ uint64 hex_value = ParseLeadingHex64Value(hex_buffer, 0);
+ decoded_url->append(1, static_cast<char>(hex_value));
+ state = kStart;
+ } else {
+ return false;
+ }
+ break;
+ case kTruncate:
+ if (ch == dir_separator) {
+ // Skip this separator, it was only put in to break up long
+ // path segments, but is not part of the URL.
+ state = kStart;
+ } else {
+ return false;
+ }
+ break;
+ case kEscapeDot:
+ decoded_url->append(1, ch);
+ state = kStart;
+ break;
+ }
+ }
+
+ // All legal encoded filenames end in kEscapeChar.
+ return (state == kEscape);
+}
+
+// Escape the given input |path| and chop any individual components
+// of the path which are greater than kMaximumSubdirectoryLength characters
+// into two chunks.
+//
+// This legacy version has several issues with aliasing of different URLs,
+// inability to represent both /a/b/c and /a/b/c/d, and inability to decode
+// the filenames back into URLs.
+//
+// But there is a large body of slurped data which depends on this format,
+// so leave it as the default for spdy_in_mem_edsm_server.
+string UrlToFilenameEncoder::LegacyEscape(const string& path) {
+ string output;
+
+ // Note: We also chop paths into medium sized 'chunks'.
+ // This is due to the incompetence of the windows
+ // filesystem, which still hasn't figured out how
+ // to deal with long filenames.
+ int last_slash = 0;
+ for (size_t index = 0; index < path.length(); index++) {
+ char ch = path[index];
+ if (ch == 0x5C)
+ last_slash = index;
+ if ((ch == 0x2D) || // hyphen
+ (ch == 0x5C) || (ch == 0x5F) || // backslash, underscore
+ ((0x30 <= ch) && (ch <= 0x39)) || // Digits [0-9]
+ ((0x41 <= ch) && (ch <= 0x5A)) || // Uppercase [A-Z]
+ ((0x61 <= ch) && (ch <= 0x7A))) { // Lowercase [a-z]
+ output.append(&path[index], 1);
+ } else {
+ char encoded[3];
+ encoded[0] = 'x';
+ encoded[1] = ch / 16;
+ encoded[1] += (encoded[1] >= 10) ? 'A' - 10 : '0';
+ encoded[2] = ch % 16;
+ encoded[2] += (encoded[2] >= 10) ? 'A' - 10 : '0';
+ output.append(encoded, 3);
+ }
+ if (index - last_slash > kMaximumSubdirectoryLength) {
+#ifdef WIN32
+ char slash = '\\';
+#else
+ char slash = '/';
+#endif
+ output.append(&slash, 1);
+ last_slash = index;
+ }
+ }
+ return output;
+}
+
+} // namespace net
diff --git a/src/net/tools/dump_cache/url_to_filename_encoder.h b/src/net/tools/dump_cache/url_to_filename_encoder.h
new file mode 100644
index 0000000..b81a854
--- /dev/null
+++ b/src/net/tools/dump_cache/url_to_filename_encoder.h
@@ -0,0 +1,211 @@
+// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// URL filename encoder goals:
+//
+// 1. Allow URLs with arbitrary path-segment length, generating filenames
+// with a maximum of 128 characters.
+// 2. Provide a somewhat human readable filenames, for easy debugging flow.
+// 3. Provide reverse-mapping from filenames back to URLs.
+// 4. Be able to distinguish http://x from http://x/ from http://x/index.html.
+// Those can all be different URLs.
+// 5. Be able to represent http://a/b/c and http://a/b/c/d, a pattern seen
+// with Facebook Connect.
+//
+// We need an escape-character for representing characters that are legal
+// in URL paths, but not in filenames, such as '?'.
+//
+// We can pick any legal character as an escape, as long as we escape it too.
+// But as we have a goal of having filenames that humans can correlate with
+// URLs, we should pick one that doesn't show up frequently in URLs. Candidates
+// are ~`!@#$%^&()-=_+{}[],. but we would prefer to avoid characters that are
+// shell escapes or that various build tools use.
+//
+// .#&%-=_+ occur frequently in URLs.
+// <>:"/\|?* are illegal in Windows
+// See http://msdn.microsoft.com/en-us/library/aa365247(VS.85).aspx
+// ~`!$^&(){}[]'; are special to Unix shells
+// In addition, build tools do not like ^@#%
+//
+// Josh took a quick look at the frequency of some special characters in
+// Sadeesh's slurped directory from Fall 09 and found the following occurances:
+//
+// ^ 3 build tool doesn't like ^ in testdata filenames
+// @ 10 build tool doesn't like @ in testdata filenames
+// . 1676 too frequent in URLs
+// , 76 THE WINNER
+// # 0 build tool doesn't like it
+// & 487 Prefer to avoid shell escapes
+// % 374 g4 doesn't like it
+// = 579 very frequent in URLs -- leave unmodified
+// - 464 very frequent in URLs -- leave unmodified
+// _ 798 very frequent in URLs -- leave unmodified
+//
+//
+// The escaping algorithm is:
+// 1) Escape all unfriendly symbols as ,XX where XX is the hex code.
+// 2) Add a ',' at the end (We do not allow ',' at end of any directory name,
+// so this assures that e.g. /a and /a/b can coexist in the filesystem).
+// 3) Go through the path segment by segment (where a segment is one directory
+// or leaf in the path) and
+// 3a) If the segment is empty, escape the second slash. i.e. if it was
+// www.foo.com//a then we escape the second / like www.foo.com/,2Fa,
+// 3a) If it is "." or ".." prepend with ',' (so that we have a non-
+// empty and non-reserved filename).
+// 3b) If it is over 128 characters, break it up into smaller segments by
+// inserting ,-/ (Windows limits paths to 128 chars, other OSes also
+// have limits that would restrict us)
+//
+// For example:
+// URL File
+// / /,
+// /index.html /index.html,
+// /. /.,
+// /a/b /a/b,
+// /a/b/ /a/b/,
+// /a/b/c /a/b/c, Note: no prefix problem
+// /u?foo=bar /u,3Ffoo=bar,
+// // /,2F,
+// /./ /,./,
+// /../ /,../,
+// /, /,2C,
+// /,./ /,2C./,
+// /very...longname/ /very...long,-/name If very...long is about 126 long.
+
+// NOTE: we avoid using some classes here (like FilePath and GURL) because we
+// share this code with other projects externally.
+
+#ifndef NET_TOOLS_DUMP_CACHE_URL_TO_FILENAME_ENCODER_H_
+#define NET_TOOLS_DUMP_CACHE_URL_TO_FILENAME_ENCODER_H_
+
+#include <string>
+
+#include "base/string_util.h"
+#include "net/tools/dump_cache/url_utilities.h"
+
+namespace net {
+
+// Helper class for converting a URL into a filename.
+class UrlToFilenameEncoder {
+ public:
+ // Given a |url| and a |base_path|, returns a filename which represents this
+ // |url|. |url| may include URL escaping such as %21 for !
+ // |legacy_escape| indicates that this function should use the old-style
+ // of encoding.
+ // TODO(mbelshe): delete the legacy_escape code.
+ static std::string Encode(const std::string& url, std::string base_path,
+ bool legacy_escape) {
+ std::string filename;
+ if (!legacy_escape) {
+ std::string url_no_scheme = UrlUtilities::GetUrlHostPath(url);
+ EncodeSegment(base_path, url_no_scheme, '/', &filename);
+#ifdef WIN32
+ ReplaceAll(&filename, "/", "\\");
+#endif
+ } else {
+ std::string clean_url(url);
+ if (clean_url.length() && clean_url[clean_url.length()-1] == '/')
+ clean_url.append("index.html");
+
+ std::string host = UrlUtilities::GetUrlHost(clean_url);
+ filename.append(base_path);
+ filename.append(host);
+#ifdef WIN32
+ filename.append("\\");
+#else
+ filename.append("/");
+#endif
+
+ std::string url_filename = UrlUtilities::GetUrlPath(clean_url);
+ // Strip the leading '/'.
+ if (url_filename[0] == '/')
+ url_filename = url_filename.substr(1);
+
+ // Replace '/' with '\'.
+ ConvertToSlashes(&url_filename);
+
+ // Strip double back-slashes ("\\\\").
+ StripDoubleSlashes(&url_filename);
+
+ // Save path as filesystem-safe characters.
+ url_filename = LegacyEscape(url_filename);
+ filename.append(url_filename);
+
+#ifndef WIN32
+ // Last step - convert to native slashes.
+ const std::string slash("/");
+ const std::string backslash("\\");
+ ReplaceAll(&filename, backslash, slash);
+#endif
+ }
+
+ return filename;
+ }
+
+ // Rewrite HTML in a form that the SPDY in-memory server
+ // can read.
+ // |filename_prefix| is prepended without escaping.
+ // |escaped_ending| is the URL to be encoded into a filename. It may have URL
+ // escaped characters (like %21 for !).
+ // |dir_separator| is "/" on Unix, "\" on Windows.
+ // |encoded_filename| is the resultant filename.
+ static void EncodeSegment(
+ const std::string& filename_prefix,
+ const std::string& escaped_ending,
+ char dir_separator,
+ std::string* encoded_filename);
+
+ // Decodes a filename that was encoded with EncodeSegment,
+ // yielding back the original URL.
+ static bool Decode(const std::string& encoded_filename,
+ char dir_separator,
+ std::string* decoded_url);
+
+ static const char kEscapeChar;
+ static const char kTruncationChar;
+ static const size_t kMaximumSubdirectoryLength;
+
+ friend class UrlToFilenameEncoderTest;
+
+ private:
+ // Appends a segment of the path, special-casing "." and "..", and
+ // ensuring that the segment does not exceed the path length. If it does,
+ // it chops the end off the segment, writes the segment with a separator of
+ // ",-/", and then rewrites segment to contain just the truncated piece so
+ // it can be used in the next iteration.
+ // |segment| is a read/write parameter containing segment to write
+ // Note: this should not be called with empty segment.
+ static void AppendSegment(std::string* segment, std::string* dest);
+
+ // Allow reading of old slurped files.
+ static std::string LegacyEscape(const std::string& path);
+
+ // Replace all instances of |from| within |str| as |to|.
+ static void ReplaceAll(std::string* str, const std::string& from,
+ const std::string& to) {
+ std::string::size_type pos(0);
+ while ((pos = str->find(from, pos)) != std::string::npos) {
+ str->replace(pos, from.size(), to);
+ pos += from.size();
+ }
+ }
+
+ // Replace all instances of "/" with "\" in |path|.
+ static void ConvertToSlashes(std::string* path) {
+ const std::string slash("/");
+ const std::string backslash("\\");
+ ReplaceAll(path, slash, backslash);
+ }
+
+ // Replace all instances of "\\" with "%5C%5C" in |path|.
+ static void StripDoubleSlashes(std::string* path) {
+ const std::string doubleslash("\\\\");
+ const std::string escaped_doubleslash("%5C%5C");
+ ReplaceAll(path, doubleslash, escaped_doubleslash);
+ }
+};
+
+} // namespace net
+
+#endif // NET_TOOLS_DUMP_CACHE_URL_TO_FILENAME_ENCODER_H_
diff --git a/src/net/tools/dump_cache/url_to_filename_encoder_unittest.cc b/src/net/tools/dump_cache/url_to_filename_encoder_unittest.cc
new file mode 100644
index 0000000..2e09e0b
--- /dev/null
+++ b/src/net/tools/dump_cache/url_to_filename_encoder_unittest.cc
@@ -0,0 +1,341 @@
+// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "net/tools/dump_cache/url_to_filename_encoder.h"
+
+#include <string>
+#include <vector>
+
+#include "base/string_piece.h"
+#include "base/string_util.h"
+#include "base/stringprintf.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using base::StringPiece;
+using std::string;
+
+namespace net {
+
+#ifdef WIN32
+char kDirSeparator = '\\';
+char kOtherDirSeparator = '/';
+#else
+char kDirSeparator = '/';
+char kOtherDirSeparator = '\\';
+#endif
+
+class UrlToFilenameEncoderTest : public ::testing::Test {
+ protected:
+ UrlToFilenameEncoderTest() : escape_(1, UrlToFilenameEncoder::kEscapeChar),
+ dir_sep_(1, kDirSeparator) {
+ }
+
+ void CheckSegmentLength(const StringPiece& escaped_word) {
+ std::vector<StringPiece> components;
+ Tokenize(escaped_word, StringPiece("/"), &components);
+ for (size_t i = 0; i < components.size(); ++i) {
+ EXPECT_GE(UrlToFilenameEncoder::kMaximumSubdirectoryLength,
+ components[i].size());
+ }
+ }
+
+ void CheckValidChars(const StringPiece& escaped_word, char invalid_slash) {
+ // These characters are invalid in Windows. We add in ', as that's pretty
+ // inconvenient in a Unix filename.
+ //
+ // See http://msdn.microsoft.com/en-us/library/aa365247(VS.85).aspx
+ const string kInvalidChars = "<>:\"|?*'";
+ for (size_t i = 0; i < escaped_word.size(); ++i) {
+ char c = escaped_word[i];
+ EXPECT_EQ(string::npos, kInvalidChars.find(c));
+ EXPECT_NE(invalid_slash, c);
+ EXPECT_NE('\0', c); // only invalid character in Posix
+ EXPECT_GT(0x7E, c); // only English printable characters
+ }
+ }
+
+ void Validate(const string& in_word, const string& gold_word) {
+ string escaped_word, url;
+ UrlToFilenameEncoder::EncodeSegment("", in_word, '/', &escaped_word);
+ EXPECT_EQ(gold_word, escaped_word);
+ CheckSegmentLength(escaped_word);
+ CheckValidChars(escaped_word, '\\');
+ UrlToFilenameEncoder::Decode(escaped_word, '/', &url);
+ EXPECT_EQ(in_word, url);
+ }
+
+ void ValidateAllSegmentsSmall(const string& in_word) {
+ string escaped_word, url;
+ UrlToFilenameEncoder::EncodeSegment("", in_word, '/', &escaped_word);
+ CheckSegmentLength(escaped_word);
+ CheckValidChars(escaped_word, '\\');
+ UrlToFilenameEncoder::Decode(escaped_word, '/', &url);
+ EXPECT_EQ(in_word, url);
+ }
+
+ void ValidateNoChange(const string& word) {
+ // We always suffix the leaf with kEscapeChar, unless the leaf is empty.
+ Validate(word, word + escape_);
+ }
+
+ void ValidateEscaped(unsigned char ch) {
+ // We always suffix the leaf with kEscapeChar, unless the leaf is empty.
+ char escaped[100];
+ const char escape = UrlToFilenameEncoder::kEscapeChar;
+ base::snprintf(escaped, sizeof(escaped), "%c%02X%c", escape, ch, escape);
+ Validate(string(1, ch), escaped);
+ }
+
+ void ValidateUrl(const string& url, const string& base_path,
+ bool legacy_escape, const string& gold_filename) {
+ string encoded_filename = UrlToFilenameEncoder::Encode(
+ url, base_path, legacy_escape);
+ EXPECT_EQ(gold_filename, encoded_filename);
+ if (!legacy_escape) {
+ CheckSegmentLength(encoded_filename);
+ CheckValidChars(encoded_filename, kOtherDirSeparator);
+ string decoded_url;
+ UrlToFilenameEncoder::Decode(encoded_filename, kDirSeparator,
+ &decoded_url);
+ if (url != decoded_url) {
+ EXPECT_EQ(url, "http://" + decoded_url);
+ }
+ }
+ }
+
+ void ValidateUrlOldNew(const string& url, const string& gold_old_filename,
+ const string& gold_new_filename) {
+ ValidateUrl(url, "", true, gold_old_filename);
+ ValidateUrl(url, "", false, gold_new_filename);
+ }
+
+ void ValidateEncodeSame(const string& url1, const string& url2) {
+ string filename1 = UrlToFilenameEncoder::Encode(url1, "", false);
+ string filename2 = UrlToFilenameEncoder::Encode(url2, "", false);
+ EXPECT_EQ(filename1, filename2);
+ }
+
+ string escape_;
+ string dir_sep_;
+};
+
+TEST_F(UrlToFilenameEncoderTest, DoesNotEscape) {
+ ValidateNoChange("");
+ ValidateNoChange("abcdefg");
+ ValidateNoChange("abcdefghijklmnopqrstuvwxyz");
+ ValidateNoChange("ZYXWVUT");
+ ValidateNoChange("ZYXWVUTSRQPONMLKJIHGFEDCBA");
+ ValidateNoChange("01234567689");
+ ValidateNoChange("_.=+-");
+ ValidateNoChange("abcdefghijklmnopqrstuvwxyzZYXWVUTSRQPONMLKJIHGFEDCBA"
+ "01234567689_.=+-");
+ ValidateNoChange("index.html");
+ ValidateNoChange("/");
+ ValidateNoChange("/.");
+ ValidateNoChange(".");
+ ValidateNoChange("..");
+}
+
+TEST_F(UrlToFilenameEncoderTest, Escapes) {
+ const string bad_chars =
+ "<>:\"\\|?*" // Illegal on Windows
+ "~`!$^&(){}[]';" // Bad for Unix shells
+ "^@" // Build tool doesn't like
+ "#%" // Tool doesn't like
+ ","; // The escape char has to be escaped
+
+ for (size_t i = 0; i < bad_chars.size(); ++i) {
+ ValidateEscaped(bad_chars[i]);
+ }
+
+ // Check non-printable characters.
+ ValidateEscaped('\0');
+ for (size_t i = 127; i < 256; ++i) {
+ ValidateEscaped(static_cast<char>(i));
+ }
+}
+
+TEST_F(UrlToFilenameEncoderTest, DoesEscapeCorrectly) {
+ Validate("mysite.com&x", "mysite.com" + escape_ + "26x" + escape_);
+ Validate("/./", "/" + escape_ + "./" + escape_);
+ Validate("/../", "/" + escape_ + "../" + escape_);
+ Validate("//", "/" + escape_ + "2F" + escape_);
+ Validate("/./leaf", "/" + escape_ + "./leaf" + escape_);
+ Validate("/../leaf", "/" + escape_ + "../leaf" + escape_);
+ Validate("//leaf", "/" + escape_ + "2Fleaf" + escape_);
+ Validate("mysite/u?param1=x¶m2=y",
+ "mysite/u" + escape_ + "3Fparam1=x" + escape_ + "26param2=y" +
+ escape_);
+ Validate("search?q=dogs&go=&form=QBLH&qs=n", // from Latency Labs bing test.
+ "search" + escape_ + "3Fq=dogs" + escape_ + "26go=" + escape_ +
+ "26form=QBLH" + escape_ + "26qs=n" + escape_);
+ Validate("~joebob/my_neeto-website+with_stuff.asp?id=138&content=true",
+ "" + escape_ + "7Ejoebob/my_neeto-website+with_stuff.asp" + escape_ +
+ "3Fid=138" + escape_ + "26content=true" + escape_);
+}
+
+TEST_F(UrlToFilenameEncoderTest, EncodeUrlCorrectly) {
+ ValidateUrlOldNew("http://www.google.com/index.html",
+ "www.google.com" + dir_sep_ + "indexx2Ehtml",
+ "www.google.com" + dir_sep_ + "index.html" + escape_);
+ ValidateUrlOldNew("http://www.google.com/x/search?hl=en&q=dogs&oq=",
+ "www.google.com" + dir_sep_ + "x" + dir_sep_ +
+ "searchx3Fhlx3Denx26qx3Ddogsx26oqx3D",
+
+ "www.google.com" + dir_sep_ + "x" + dir_sep_ + "search" +
+ escape_ + "3Fhl=en" + escape_ + "26q=dogs" + escape_ +
+ "26oq=" + escape_);
+ ValidateUrlOldNew("http://www.foo.com/a//",
+ "www.foo.com" + dir_sep_ + "ax255Cx255Cindexx2Ehtml",
+ "www.foo.com" + dir_sep_ + "a" + dir_sep_ + escape_ + "2F" +
+ escape_);
+
+ // From bug: Double slash preserved.
+ ValidateUrl("http://www.foo.com/u?site=http://www.google.com/index.html",
+ "", false,
+ "www.foo.com" + dir_sep_ + "u" + escape_ + "3Fsite=http" +
+ escape_ + "3A" + dir_sep_ + escape_ + "2Fwww.google.com" +
+ dir_sep_ + "index.html" + escape_);
+ ValidateUrlOldNew(
+ "http://blogutils.net/olct/online.php?"
+ "site=http://thelwordfanfics.blogspot.&interval=600",
+
+ "blogutils.net" + dir_sep_ + "olct" + dir_sep_ + "onlinex2Ephpx3F"
+ "sitex3Dhttpx3Ax255Cx255Cthelwordfanficsx2Eblogspotx2Ex26intervalx3D600",
+
+ "blogutils.net" + dir_sep_ + "olct" + dir_sep_ + "online.php" + escape_ +
+ "3Fsite=http" + escape_ + "3A" + dir_sep_ + escape_ +
+ "2Fthelwordfanfics.blogspot." + escape_ + "26interval=600" + escape_);
+}
+
+// From bug: Escapes treated the same as normal char.
+TEST_F(UrlToFilenameEncoderTest, UnescapeUrlsBeforeEncode) {
+ for (int i = 0; i < 128; ++i) {
+ string unescaped(1, static_cast<char>(i));
+ string escaped = base::StringPrintf("%%%02X", i);
+ ValidateEncodeSame(unescaped, escaped);
+ }
+
+ ValidateEncodeSame(
+ "http://www.blogger.com/navbar.g?bName=God!&Mode=FOO&searchRoot"
+ "=http%3A%2F%2Fsurvivorscanthrive.blogspot.com%2Fsearch",
+
+ "http://www.blogger.com/navbar.g?bName=God%21&Mode=FOO&searchRoot"
+ "=http%3A%2F%2Fsurvivorscanthrive.blogspot.com%2Fsearch");
+}
+
+// From bug: Filename encoding is not prefix-free.
+TEST_F(UrlToFilenameEncoderTest, EscapeSecondSlash) {
+ Validate("/", "/" + escape_);
+ Validate("//", "/" + escape_ + "2F" + escape_);
+ Validate("///", "/" + escape_ + "2F" + "/" + escape_);
+}
+
+TEST_F(UrlToFilenameEncoderTest, LongTail) {
+ static char long_word[] =
+ "~joebob/briggs/12345678901234567890123456789012345678901234567890"
+ "1234567890123456789012345678901234567890123456789012345678901234567890"
+ "1234567890123456789012345678901234567890123456789012345678901234567890"
+ "1234567890123456789012345678901234567890123456789012345678901234567890"
+ "1234567890123456789012345678901234567890123456789012345678901234567890"
+ "1234567890123456789012345678901234567890123456789012345678901234567890";
+
+ // the long lines in the string below are 64 characters, so we can see
+ // the slashes every 128.
+ string gold_long_word =
+ escape_ + "7Ejoebob/briggs/"
+ "1234567890123456789012345678901234567890123456789012345678901234"
+ "56789012345678901234567890123456789012345678901234567890123456" +
+ escape_ + "-/"
+ "7890123456789012345678901234567890123456789012345678901234567890"
+ "12345678901234567890123456789012345678901234567890123456789012" +
+ escape_ + "-/"
+ "3456789012345678901234567890123456789012345678901234567890123456"
+ "78901234567890123456789012345678901234567890123456789012345678" +
+ escape_ + "-/"
+ "9012345678901234567890" + escape_;
+ EXPECT_LT(UrlToFilenameEncoder::kMaximumSubdirectoryLength,
+ sizeof(long_word));
+ Validate(long_word, gold_long_word);
+}
+
+TEST_F(UrlToFilenameEncoderTest, LongTailQuestion) {
+ // Here the '?' in the last path segment expands to @3F, making
+ // it hit 128 chars before the input segment gets that big.
+ static char long_word[] =
+ "~joebob/briggs/1234567?1234567?1234567?1234567?1234567?"
+ "1234567?1234567?1234567?1234567?1234567?1234567?1234567?"
+ "1234567?1234567?1234567?1234567?1234567?1234567?1234567?"
+ "1234567?1234567?1234567?1234567?1234567?1234567?1234567?"
+ "1234567?1234567?1234567?1234567?1234567?1234567?1234567?"
+ "1234567?1234567?1234567?1234567?1234567?1234567?1234567?";
+
+ // Notice that at the end of the third segment, we avoid splitting
+ // the (escape_ + "3F") that was generated from the "?", so that segment is
+ // only 127 characters.
+ string pattern = "1234567" + escape_ + "3F"; // 10 characters
+ string gold_long_word =
+ escape_ + "7Ejoebob/briggs/" +
+ pattern + pattern + pattern + pattern + pattern + pattern + "1234"
+ "567" + escape_ + "3F" + pattern + pattern + pattern + pattern + pattern +
+ "123456" + escape_ + "-/"
+ "7" + escape_ + "3F" + pattern + pattern + pattern + pattern + pattern +
+ pattern + pattern + pattern + pattern + pattern + pattern + pattern +
+ "12" +
+ escape_ + "-/"
+ "34567" + escape_ + "3F" + pattern + pattern + pattern + pattern + pattern
+ + "1234567" + escape_ + "3F" + pattern + pattern + pattern + pattern
+ + pattern + "1234567" +
+ escape_ + "-/" +
+ escape_ + "3F" + pattern + pattern + escape_;
+ EXPECT_LT(UrlToFilenameEncoder::kMaximumSubdirectoryLength,
+ sizeof(long_word));
+ Validate(long_word, gold_long_word);
+}
+
+TEST_F(UrlToFilenameEncoderTest, CornerCasesNearMaxLenNoEscape) {
+ // hit corner cases, +/- 4 characters from kMaxLen
+ for (int i = -4; i <= 4; ++i) {
+ string input;
+ input.append(i + UrlToFilenameEncoder::kMaximumSubdirectoryLength, 'x');
+ ValidateAllSegmentsSmall(input);
+ }
+}
+
+TEST_F(UrlToFilenameEncoderTest, CornerCasesNearMaxLenWithEscape) {
+ // hit corner cases, +/- 4 characters from kMaxLen. This time we
+ // leave off the last 'x' and put in a '.', which ensures that we
+ // are truncating with '/' *after* the expansion.
+ for (int i = -4; i <= 4; ++i) {
+ string input;
+ input.append(i + UrlToFilenameEncoder::kMaximumSubdirectoryLength - 1, 'x');
+ input.append(1, '.'); // this will expand to 3 characters.
+ ValidateAllSegmentsSmall(input);
+ }
+}
+
+TEST_F(UrlToFilenameEncoderTest, LeafBranchAlias) {
+ Validate("/a/b/c", "/a/b/c" + escape_); // c is leaf file "c,"
+ Validate("/a/b/c/d", "/a/b/c/d" + escape_); // c is directory "c"
+ Validate("/a/b/c/d/", "/a/b/c/d/" + escape_);
+}
+
+
+TEST_F(UrlToFilenameEncoderTest, BackslashSeparator) {
+ string long_word;
+ string escaped_word;
+ long_word.append(UrlToFilenameEncoder::kMaximumSubdirectoryLength + 1, 'x');
+ UrlToFilenameEncoder::EncodeSegment("", long_word, '\\', &escaped_word);
+
+ // check that one backslash, plus the escape ",-", and the ending , got added.
+ EXPECT_EQ(long_word.size() + 4, escaped_word.size());
+ ASSERT_LT(UrlToFilenameEncoder::kMaximumSubdirectoryLength,
+ escaped_word.size());
+ // Check that the backslash got inserted at the correct spot.
+ EXPECT_EQ('\\', escaped_word[
+ UrlToFilenameEncoder::kMaximumSubdirectoryLength]);
+}
+
+} // namespace net
+
diff --git a/src/net/tools/dump_cache/url_utilities.cc b/src/net/tools/dump_cache/url_utilities.cc
new file mode 100644
index 0000000..fe64bd9
--- /dev/null
+++ b/src/net/tools/dump_cache/url_utilities.cc
@@ -0,0 +1,126 @@
+// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "net/tools/dump_cache/url_utilities.h"
+
+#include "base/logging.h"
+#include "base/string_number_conversions.h"
+#include "base/string_util.h"
+
+namespace net {
+
+std::string UrlUtilities::GetUrlHost(const std::string& url) {
+ size_t b = url.find("//");
+ if (b == std::string::npos)
+ b = 0;
+ else
+ b += 2;
+ size_t next_slash = url.find_first_of('/', b);
+ size_t next_colon = url.find_first_of(':', b);
+ if (next_slash != std::string::npos
+ && next_colon != std::string::npos
+ && next_colon < next_slash) {
+ return std::string(url, b, next_colon - b);
+ }
+ if (next_slash == std::string::npos) {
+ if (next_colon != std::string::npos) {
+ return std::string(url, b, next_colon - b);
+ } else {
+ next_slash = url.size();
+ }
+ }
+ return std::string(url, b, next_slash - b);
+}
+
+std::string UrlUtilities::GetUrlHostPath(const std::string& url) {
+ size_t b = url.find("//");
+ if (b == std::string::npos)
+ b = 0;
+ else
+ b += 2;
+ return std::string(url, b);
+}
+
+std::string UrlUtilities::GetUrlPath(const std::string& url) {
+ size_t b = url.find("//");
+ if (b == std::string::npos)
+ b = 0;
+ else
+ b += 2;
+ b = url.find("/", b);
+ if (b == std::string::npos)
+ return "/";
+
+ size_t e = url.find("#", b+1);
+ if (e != std::string::npos)
+ return std::string(url, b, (e - b));
+ return std::string(url, b);
+}
+
+namespace {
+
+// Parsing states for UrlUtilities::Unescape
+enum UnescapeState {
+ NORMAL, // We are not in the middle of parsing an escape.
+ ESCAPE1, // We just parsed % .
+ ESCAPE2 // We just parsed %X for some hex digit X.
+};
+
+} // namespace
+
+std::string UrlUtilities::Unescape(const std::string& escaped_url) {
+ std::string unescaped_url, escape_text;
+ int escape_value;
+ UnescapeState state = NORMAL;
+ std::string::const_iterator iter = escaped_url.begin();
+ while (iter < escaped_url.end()) {
+ char c = *iter;
+ switch (state) {
+ case NORMAL:
+ if (c == '%') {
+ escape_text.clear();
+ state = ESCAPE1;
+ } else {
+ unescaped_url.push_back(c);
+ }
+ ++iter;
+ break;
+ case ESCAPE1:
+ if (IsHexDigit(c)) {
+ escape_text.push_back(c);
+ state = ESCAPE2;
+ ++iter;
+ } else {
+ // Unexpected, % followed by non-hex chars, pass it through.
+ unescaped_url.push_back('%');
+ state = NORMAL;
+ }
+ break;
+ case ESCAPE2:
+ if (IsHexDigit(c)) {
+ escape_text.push_back(c);
+ bool ok = base::HexStringToInt(escape_text, &escape_value);
+ DCHECK(ok);
+ unescaped_url.push_back(static_cast<unsigned char>(escape_value));
+ state = NORMAL;
+ ++iter;
+ } else {
+ // Unexpected, % followed by non-hex chars, pass it through.
+ unescaped_url.push_back('%');
+ unescaped_url.append(escape_text);
+ state = NORMAL;
+ }
+ break;
+ }
+ }
+ // Unexpected, % followed by end of string, pass it through.
+ if (state == ESCAPE1 || state == ESCAPE2) {
+ unescaped_url.push_back('%');
+ unescaped_url.append(escape_text);
+ }
+ return unescaped_url;
+}
+
+} // namespace net
+
diff --git a/src/net/tools/dump_cache/url_utilities.h b/src/net/tools/dump_cache/url_utilities.h
new file mode 100644
index 0000000..c9d8ea5
--- /dev/null
+++ b/src/net/tools/dump_cache/url_utilities.h
@@ -0,0 +1,35 @@
+// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef NET_TOOLS_DUMP_CACHE_URL_UTILITIES_H_
+#define NET_TOOLS_DUMP_CACHE_URL_UTILITIES_H_
+
+#include <string>
+
+namespace net {
+
+struct UrlUtilities {
+ // Gets the host from an url, strips the port number as well if the url
+ // has one.
+ // For example: calling GetUrlHost(www.foo.com:8080/boo) returns www.foo.com
+ static std::string GetUrlHost(const std::string& url);
+
+ // Get the host + path portion of an url
+ // e.g http://www.foo.com/path
+ // returns www.foo.com/path
+ static std::string GetUrlHostPath(const std::string& url);
+
+ // Gets the path portion of an url.
+ // e.g http://www.foo.com/path
+ // returns /path
+ static std::string GetUrlPath(const std::string& url);
+
+ // Unescape a url, converting all %XX to the the actual char 0xXX.
+ // For example, this will convert "foo%21bar" to "foo!bar".
+ static std::string Unescape(const std::string& escaped_url);
+};
+
+} // namespace net
+
+#endif // NET_TOOLS_DUMP_CACHE_URL_UTILITIES_H_
diff --git a/src/net/tools/dump_cache/url_utilities_unittest.cc b/src/net/tools/dump_cache/url_utilities_unittest.cc
new file mode 100644
index 0000000..0f9cb06
--- /dev/null
+++ b/src/net/tools/dump_cache/url_utilities_unittest.cc
@@ -0,0 +1,114 @@
+// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "net/tools/dump_cache/url_utilities.h"
+
+#include <string>
+
+#include "base/string_util.h"
+#include "base/stringprintf.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace net {
+
+TEST(UrlUtilitiesTest, GetUrlHost) {
+ EXPECT_EQ("www.foo.com",
+ UrlUtilities::GetUrlHost("http://www.foo.com"));
+ EXPECT_EQ("www.foo.com",
+ UrlUtilities::GetUrlHost("http://www.foo.com:80"));
+ EXPECT_EQ("www.foo.com",
+ UrlUtilities::GetUrlHost("http://www.foo.com:80/"));
+ EXPECT_EQ("www.foo.com",
+ UrlUtilities::GetUrlHost("http://www.foo.com/news"));
+ EXPECT_EQ("www.foo.com",
+ UrlUtilities::GetUrlHost("www.foo.com:80/news?q=hello"));
+ EXPECT_EQ("www.foo.com",
+ UrlUtilities::GetUrlHost("www.foo.com/news?q=a:b"));
+ EXPECT_EQ("www.foo.com",
+ UrlUtilities::GetUrlHost("www.foo.com:80"));
+}
+
+TEST(UrlUtilitiesTest, GetUrlHostPath) {
+ EXPECT_EQ("www.foo.com",
+ UrlUtilities::GetUrlHostPath("http://www.foo.com"));
+ EXPECT_EQ("www.foo.com:80",
+ UrlUtilities::GetUrlHostPath("http://www.foo.com:80"));
+ EXPECT_EQ("www.foo.com:80/",
+ UrlUtilities::GetUrlHostPath("http://www.foo.com:80/"));
+ EXPECT_EQ("www.foo.com/news",
+ UrlUtilities::GetUrlHostPath("http://www.foo.com/news"));
+ EXPECT_EQ("www.foo.com:80/news?q=hello",
+ UrlUtilities::GetUrlHostPath("www.foo.com:80/news?q=hello"));
+ EXPECT_EQ("www.foo.com/news?q=a:b",
+ UrlUtilities::GetUrlHostPath("www.foo.com/news?q=a:b"));
+ EXPECT_EQ("www.foo.com:80",
+ UrlUtilities::GetUrlHostPath("www.foo.com:80"));
+}
+
+TEST(UrlUtilitiesTest, GetUrlPath) {
+ EXPECT_EQ("/",
+ UrlUtilities::GetUrlPath("http://www.foo.com"));
+ EXPECT_EQ("/",
+ UrlUtilities::GetUrlPath("http://www.foo.com:80"));
+ EXPECT_EQ("/",
+ UrlUtilities::GetUrlPath("http://www.foo.com:80/"));
+ EXPECT_EQ("/news",
+ UrlUtilities::GetUrlPath("http://www.foo.com/news"));
+ EXPECT_EQ("/news?q=hello",
+ UrlUtilities::GetUrlPath("www.foo.com:80/news?q=hello"));
+ EXPECT_EQ("/news?q=a:b",
+ UrlUtilities::GetUrlPath("www.foo.com/news?q=a:b"));
+ EXPECT_EQ("/",
+ UrlUtilities::GetUrlPath("www.foo.com:80"));
+}
+
+TEST(UrlUtilitiesTest, Unescape) {
+ // Basic examples are left alone.
+ EXPECT_EQ("http://www.foo.com",
+ UrlUtilities::Unescape("http://www.foo.com"));
+ EXPECT_EQ("www.foo.com:80/news?q=hello",
+ UrlUtilities::Unescape("www.foo.com:80/news?q=hello"));
+
+ // All chars can be unescaped.
+ EXPECT_EQ("~`!@#$%^&*()_-+={[}]|\\:;\"'<,>.?/",
+ UrlUtilities::Unescape("%7E%60%21%40%23%24%25%5E%26%2A%28%29%5F%2D"
+ "%2B%3D%7B%5B%7D%5D%7C%5C%3A%3B%22%27%3C%2C"
+ "%3E%2E%3F%2F"));
+ for (int c = 0; c < 256; ++c) {
+ std::string unescaped_char(1, implicit_cast<unsigned char>(c));
+ std::string escaped_char = base::StringPrintf("%%%02X", c);
+ EXPECT_EQ(unescaped_char, UrlUtilities::Unescape(escaped_char))
+ << "escaped_char = " << escaped_char;
+ escaped_char = base::StringPrintf("%%%02x", c);
+ EXPECT_EQ(unescaped_char, UrlUtilities::Unescape(escaped_char))
+ << "escaped_char = " << escaped_char;
+ }
+
+ // All non-% chars are left alone.
+ EXPECT_EQ("~`!@#$^&*()_-+={[}]|\\:;\"'<,>.?/",
+ UrlUtilities::Unescape("~`!@#$^&*()_-+={[}]|\\:;\"'<,>.?/"));
+ for (int c = 0; c < 256; ++c) {
+ if (c != '%') {
+ std::string just_char(1, implicit_cast<unsigned char>(c));
+ EXPECT_EQ(just_char, UrlUtilities::Unescape(just_char));
+ }
+ }
+
+ // Some examples to unescape.
+ EXPECT_EQ("Hello, world!", UrlUtilities::Unescape("Hello%2C world%21"));
+
+ // Not actually escapes.
+ EXPECT_EQ("%", UrlUtilities::Unescape("%"));
+ EXPECT_EQ("%www", UrlUtilities::Unescape("%www"));
+ EXPECT_EQ("%foo", UrlUtilities::Unescape("%foo"));
+ EXPECT_EQ("%1", UrlUtilities::Unescape("%1"));
+ EXPECT_EQ("%1x", UrlUtilities::Unescape("%1x"));
+ EXPECT_EQ("%%", UrlUtilities::Unescape("%%"));
+ // Escapes following non-escapes.
+ EXPECT_EQ("%!", UrlUtilities::Unescape("%%21"));
+ EXPECT_EQ("%2!", UrlUtilities::Unescape("%2%21"));
+}
+
+} // namespace net
+
diff --git a/src/starboard/linux/x64directfb/xephyr_run.sh b/src/starboard/linux/x64directfb/xephyr_run.sh
index dc3181c..77bf969 100755
--- a/src/starboard/linux/x64directfb/xephyr_run.sh
+++ b/src/starboard/linux/x64directfb/xephyr_run.sh
@@ -13,44 +13,123 @@
# See the License for the specific language governing permissions and
# limitations under the License.
-# This script can be used as a convenience to launch an app under a Xephyr
-# X server. It will first launch Xephyr, and then launch the executable given
-# on the command line such that it targets and will appear within the Xephyr
-# window. It shuts down Xephyr after the main executable finishes.
+# This script can be used as a convenience to launch an app under a new
+# X server. Xephyr requires a base X server, so will be launched if there is a
+# DISPLAY environment variable set. Xvfb does not, so it will be launched if
+# there is no DISPLAY variable set, which is likely to come from a remote shell
+# or background process. It will first launch the X server, and then launch the
+# executable given on the command line such that it targets the newly-launched
+# X server. It shuts down the X server after the main executable finishes.
-if [[ $# = 0 ]]; then
- echo
- echo "$0 will launch a given executable file under a Xephyr X server."
- echo
- echo "Usage:"
- echo " $0 PATH_TO_EXECUTABLE_FILE "
- echo
- exit 0
+# Standard stuff to get the real script name.
+script_file="$(readlink -f "${BASH_SOURCE[0]}")"
+script_name="$(basename "${script_file}")"
+
+if [[ -n "$DISPLAY" ]]; then
+ # The binary to run to start the X Server.
+ xserver_bin=Xephyr
+ # The command-line args to set the screen dimensions.
+ declare -a xserver_screen=(-screen 1920x1080)
+ # The package to install for this X Server.
+ xserver_package=xserver-xephyr
+else
+ xserver_bin=Xvfb
+ declare -a xserver_screen=(-screen 0 1920x1080x24)
+ xserver_package=xvfb
fi
-if ! hash Xephyr 2>/dev/null ; then
- echo
- echo "Xephyr is not installed. Please run:"
- echo " sudo apt-get install xserver-xephyr"
- echo
- exit 0
-fi
+# Use display 42 as it is unlikely to be used by another process on this host.
+# TODO: Scan displays for a free one.
+xserver_display=":42"
-# Open up a Xephyr display.
-Xephyr -screen 1920x1080 :10 2> /dev/null &
-xephyr_pid=$!
+function log() {
+ echo "${script_name}: $@"
+}
-# Setup a trap to clean up Xephyr upon termination of this script
-function kill1() {
+function deleteTempTrap() {
+ # If something interrupted the script, it might have printed a partial line.
+ echo
+ deleteDirectory "${temp_dir}"
+}
+
+function killServerTrap() {
+ echo
# Kill the Xephyr process.
- kill $xephyr_pid 2> /dev/null
+ kill "${xserver_pid}" &> /dev/null
# Waits for the kill to finish.
wait
+ log "${xserver_bin} (pid ${xserver_pid}) terminated."
+ deleteDirectory "${temp_dir}"
}
-trap kill1 EXIT
-# Give Xephyr some time to setup.
-sleep 0.5
+function deleteDirectory() {
+ if [[ -z "$1" ]]; then
+ log "deleteDirectory with no argument"
+ exit 1
+ fi
-# Launch the executable passed as a parameter on the Xephyr display.
-DISPLAY=:10 $@
\ No newline at end of file
+ # Only delete target if it is an existing directory.
+ if [[ -d "$1" ]]; then
+ rm -rf "$1"
+ fi
+}
+
+function main() {
+ if [[ "$#" = "0" ]]; then
+ echo
+ echo "${script_name}: Launches a given executable file under a ${xserver_bin} X server."
+ echo
+ echo "Usage:"
+ echo " ${script_name} PATH_TO_EXECUTABLE_FILE [ARGS...] "
+ echo
+ exit 1
+ fi
+
+ if ! hash "${xserver_bin}" 2>/dev/null ; then
+ log "${xserver_bin} is not installed. Please run:"
+ log " sudo apt-get install ${xserver_package}"
+ exit 1
+ fi
+
+ # Create an auth file that will allow the current user to access the display.
+ temp_dir="$(mktemp -dt "${script_name}.XXXXXXXXXX")"
+
+ # Delete the temporary directory on exit.
+ trap deleteTempTrap EXIT
+
+ # In this case, we don't want to try to tunnel authority through to remote
+ # connections, we want to use this X server with the client. So we create
+ # our own auth and forcibly pass it through both sides of the client and
+ # server. Apologies for the X11 magic here.
+ xserver_auth="${temp_dir}/XAuthority"
+ touch "${xserver_auth}"
+ token="$(dd if=/dev/urandom count=1 2> /dev/null | md5sum | cut -f1 -d' ')"
+ xauth -qf "${xserver_auth}" add "${xserver_display}" . "${token}"
+
+ xserver_log="${temp_dir}/${xserver_bin}.txt"
+ # Launch an X Server in the background at a new display.
+ "${xserver_bin}" "${xserver_display}" \
+ -auth "${xserver_auth}" \
+ "${xserver_screen[@]}" \
+ &> "${xserver_log}" &
+ xserver_pid=$!
+ log "${xserver_bin} (pid ${xserver_pid}) running on ${xserver_display}."
+
+ # Setup a trap to clean up Xephyr upon termination of this script
+ trap killServerTrap EXIT
+
+ # Give Xephyr some time to setup.
+ sleep 0.5
+
+ # Launch the executable passed as a parameter on the new display.
+ DISPLAY="${xserver_display}" XAUTHORITY="${xserver_auth}" "$@"
+ result=$?
+ if [[ "${result}" != "0" ]]; then
+ log "$1 result: ${result}"
+ log "--- ${xserver_bin} log ---------------------------------------"
+ cat "${xserver_log}"
+ fi
+ return ${result}
+}
+
+main "$@"
diff --git a/src/starboard/shared/ffmpeg/ffmpeg_video_decoder.cc b/src/starboard/shared/ffmpeg/ffmpeg_video_decoder.cc
index 6c7aec8..5bf56cd 100644
--- a/src/starboard/shared/ffmpeg/ffmpeg_video_decoder.cc
+++ b/src/starboard/shared/ffmpeg/ffmpeg_video_decoder.cc
@@ -150,6 +150,8 @@
SbThreadJoin(decoder_thread_, NULL);
}
+ avcodec_flush_buffers(codec_context_);
+
decoder_thread_ = kSbThreadInvalid;
stream_ended_ = false;
}
diff --git a/src/starboard/shared/starboard/player/player_worker.cc b/src/starboard/shared/starboard/player/player_worker.cc
index 5bab32b..ddb425f 100644
--- a/src/starboard/shared/starboard/player/player_worker.cc
+++ b/src/starboard/shared/starboard/player/player_worker.cc
@@ -16,6 +16,7 @@
#include <algorithm>
+#include "starboard/memory.h"
#include "starboard/shared/starboard/application.h"
#include "starboard/shared/starboard/drm/drm_system_internal.h"
#include "starboard/shared/starboard/player/audio_decoder_internal.h"
@@ -113,8 +114,11 @@
} else if (event->type == Event::kSetPause) {
running &= ProcessSetPauseEvent(event->data.set_pause);
} else if (event->type == Event::kSetBounds) {
- bounds = event->data.set_bounds;
- ProcessUpdateEvent(bounds);
+ if (SbMemoryCompare(&bounds, &event->data.set_bounds, sizeof(bounds)) !=
+ 0) {
+ bounds = event->data.set_bounds;
+ ProcessUpdateEvent(bounds);
+ }
} else if (event->type == Event::kStop) {
ProcessStopEvent();
running = false;
diff --git a/src/starboard/shared/starboard/player/video_frame_internal.cc b/src/starboard/shared/starboard/player/video_frame_internal.cc
index f13dc3b..d1a0099 100644
--- a/src/starboard/shared/starboard/player/video_frame_internal.cc
+++ b/src/starboard/shared/starboard/player/video_frame_internal.cc
@@ -30,7 +30,7 @@
int s_u_to_g[256];
int s_v_to_g[256];
int s_u_to_b[256];
-uint8_t s_clamp_table[256 * 3];
+uint8_t s_clamp_table[256 * 5];
void EnsureYUVToRGBLookupTableInitialized() {
if (s_yuv_to_rgb_lookup_table_initialized) {
@@ -47,10 +47,13 @@
//
// We optimize the conversion algorithm by creating two kinds of lookup
// tables. The color component table contains pre-calculated color component
- // values. The clamp table contains a map between |v| + 256 to the clamped
+ // values. The clamp table contains a map between |v| + 512 to the clamped
// |v| to avoid conditional operation.
- SbMemorySet(s_clamp_table, 0, 256);
- SbMemorySet(s_clamp_table + 512, 0xff, 256);
+ // The minimum value of |v| can be 2.112f * (-128) = -271, the maximum value
+ // of |v| can be 1.164f * 255 + 2.112f * 127 = 565. So we need 512 bytes at
+ // each side of the clamp buffer.
+ SbMemorySet(s_clamp_table, 0, 512);
+ SbMemorySet(s_clamp_table + 768, 0xff, 512);
for (int i = 0; i < 256; ++i) {
s_y_to_rgb[i] = (static_cast<uint8_t>(i) - 16) * 1.164f;
@@ -58,14 +61,14 @@
s_u_to_g[i] = (static_cast<uint8_t>(i) - 128) * -0.213;
s_v_to_g[i] = (static_cast<uint8_t>(i) - 128) * -0.533f;
s_u_to_b[i] = (static_cast<uint8_t>(i) - 128) * 2.112f;
- s_clamp_table[256 + i] = i;
+ s_clamp_table[512 + i] = i;
}
s_yuv_to_rgb_lookup_table_initialized = true;
}
uint8_t ClampColorComponent(int component) {
- return s_clamp_table[component + 256];
+ return s_clamp_table[component + 512];
}
} // namespace
diff --git a/src/starboard/shared/starboard/player/video_renderer_internal.cc b/src/starboard/shared/starboard/player/video_renderer_internal.cc
index da9ccf8..d3faa9f 100644
--- a/src/starboard/shared/starboard/player/video_renderer_internal.cc
+++ b/src/starboard/shared/starboard/player/video_renderer_internal.cc
@@ -70,6 +70,9 @@
seeking_ = true;
end_of_stream_written_ = false;
+ if (!frames_.empty()) {
+ seeking_frame_ = frames_.front();
+ }
frames_.clear();
}
@@ -77,8 +80,7 @@
ScopedLock lock(mutex_);
if (frames_.empty()) {
- // We cannot paint anything if there is no frames.
- return empty_frame_;
+ return seeking_frame_;
}
// Remove any frames with timestamps earlier than |media_time|, but always
// keep at least one of the frames.
@@ -122,7 +124,7 @@
frames_.push_back(*frame);
}
- if (seeking_ && frames_.size() > kPrerollFrames) {
+ if (seeking_ && frames_.size() >= kPrerollFrames) {
seeking_ = false;
}
}
diff --git a/src/starboard/shared/starboard/player/video_renderer_internal.h b/src/starboard/shared/starboard/player/video_renderer_internal.h
index f62cfda..0cf815a 100644
--- a/src/starboard/shared/starboard/player/video_renderer_internal.h
+++ b/src/starboard/shared/starboard/player/video_renderer_internal.h
@@ -70,7 +70,11 @@
bool seeking_;
Frames frames_;
- VideoFrame empty_frame_;
+ // During seeking, all frames inside |frames_| will be cleared but the app
+ // should still display the last frame it is rendering. This frame will be
+ // kept inside |seeking_frame_|. It is an empty/black frame before the video
+ // is started.
+ VideoFrame seeking_frame_;
SbMediaTime seeking_to_pts_;
bool end_of_stream_written_;
diff --git a/src/starboard/shared/x11/application_x11.cc b/src/starboard/shared/x11/application_x11.cc
index 3499bd8..bfde70b 100644
--- a/src/starboard/shared/x11/application_x11.cc
+++ b/src/starboard/shared/x11/application_x11.cc
@@ -587,6 +587,7 @@
// XLib is not thread-safe. Since we may be coming from another thread, we
// have to open another connection to the display to inject the wake-up event.
Display* display = XOpenDisplay(NULL);
+ SB_DCHECK(display);
XClientMessageEvent event = {0};
event.type = ClientMessage;
event.message_type = atom;
@@ -640,7 +641,9 @@
}
SbWindow ApplicationX11::CreateWindow(const SbWindowOptions* options) {
- EnsureX();
+ if (!EnsureX()) {
+ return kSbWindowInvalid;
+ }
SbWindow window = new SbWindowPrivate(display_, options);
windows_.push_back(window);
@@ -787,17 +790,25 @@
XSendAtom((*windows_.begin())->window, wake_up_atom_);
}
-void ApplicationX11::EnsureX() {
+bool ApplicationX11::EnsureX() {
// TODO: Consider thread-safety.
if (display_) {
- return;
+ return true;
}
XInitThreads();
XSetIOErrorHandler(IOErrorHandler);
XSetErrorHandler(ErrorHandler);
display_ = XOpenDisplay(NULL);
- SB_DCHECK(display_);
+ if (!display_) {
+ const char *display_environment = getenv("DISPLAY");
+ if (display_environment == NULL) {
+ SB_LOG(ERROR) << "Unable to open display, DISPLAY not set.";
+ } else {
+ SB_LOG(ERROR) << "Unable to open display " << display_environment << ".";
+ }
+ return false;
+ }
// Disable keyup events on auto-repeat to match Windows.
// Otherwise when holding down a key, we get a keyup event before
@@ -812,6 +823,7 @@
#if SB_IS(PLAYER_PUNCHED_OUT)
Composite();
#endif // SB_IS(PLAYER_PUNCHED_OUT)
+ return true;
}
void ApplicationX11::StopX() {
diff --git a/src/starboard/shared/x11/application_x11.h b/src/starboard/shared/x11/application_x11.h
index 4be2cab..11b4aca 100644
--- a/src/starboard/shared/x11/application_x11.h
+++ b/src/starboard/shared/x11/application_x11.h
@@ -80,8 +80,9 @@
};
#endif // SB_IS(PLAYER_PUNCHED_OUT)
- // Ensures that X is up, display is populated and connected.
- void EnsureX();
+ // Ensures that X is up, display is populated and connected, returning whether
+ // it succeeded.
+ bool EnsureX();
// Shuts X down.
void StopX();
diff --git a/src/third_party/mozjs/js/src/js.msg b/src/third_party/mozjs/js/src/js.msg
index 4047035..ff04140 100644
--- a/src/third_party/mozjs/js/src/js.msg
+++ b/src/third_party/mozjs/js/src/js.msg
@@ -297,7 +297,11 @@
MSG_DEF(JSMSG_TYPED_ARRAY_BAD_INDEX, 244, 0, JSEXN_ERR, "invalid or out-of-range index")
MSG_DEF(JSMSG_TYPED_ARRAY_NEGATIVE_ARG, 245, 1, JSEXN_ERR, "argument {0} must be >= 0")
MSG_DEF(JSMSG_TYPED_ARRAY_BAD_ARGS, 246, 0, JSEXN_ERR, "invalid arguments")
+#if defined(STARBOARD)
+MSG_DEF(JSMSG_CSP_BLOCKED_FUNCTION, 247, 0, JSEXN_EVALERR, "call to Function() blocked by CSP")
+#else
MSG_DEF(JSMSG_CSP_BLOCKED_FUNCTION, 247, 0, JSEXN_ERR, "call to Function() blocked by CSP")
+#endif
MSG_DEF(JSMSG_BAD_GET_SET_FIELD, 248, 1, JSEXN_TYPEERR, "property descriptor's {0} field is neither undefined nor a function")
MSG_DEF(JSMSG_BAD_PROXY_FIX, 249, 0, JSEXN_TYPEERR, "proxy was fixed while executing the handler")
MSG_DEF(JSMSG_INVALID_EVAL_SCOPE_ARG, 250, 0, JSEXN_EVALERR, "invalid eval scope argument")
@@ -338,7 +342,11 @@
MSG_DEF(JSMSG_DEBUG_COMPARTMENT_MISMATCH, 285, 2, JSEXN_TYPEERR, "{0}: descriptor .{1} property is an object in a different compartment than the target object")
MSG_DEF(JSMSG_DEBUG_NOT_SCRIPT_FRAME, 286, 0, JSEXN_ERR, "stack frame is not running JavaScript code")
MSG_DEF(JSMSG_CANT_WATCH_PROP, 287, 0, JSEXN_TYPEERR, "properties whose names are objects can't be watched")
+#if defined(STARBOARD)
+MSG_DEF(JSMSG_CSP_BLOCKED_EVAL, 288, 0, JSEXN_EVALERR, "call to eval() blocked by CSP")
+#else
MSG_DEF(JSMSG_CSP_BLOCKED_EVAL, 288, 0, JSEXN_ERR, "call to eval() blocked by CSP")
+#endif
MSG_DEF(JSMSG_DEBUG_NO_SCOPE_OBJECT, 289, 0, JSEXN_TYPEERR, "declarative Environments don't have binding objects")
MSG_DEF(JSMSG_EMPTY_CONSEQUENT, 290, 0, JSEXN_SYNTAXERR, "mistyped ; after conditional?")
MSG_DEF(JSMSG_NOT_ITERABLE, 291, 1, JSEXN_TYPEERR, "{0} is not iterable")
diff --git a/src/third_party/mozjs/js/src/jsapi.cpp b/src/third_party/mozjs/js/src/jsapi.cpp
index 1fae091..33b7991 100644
--- a/src/third_party/mozjs/js/src/jsapi.cpp
+++ b/src/third_party/mozjs/js/src/jsapi.cpp
@@ -93,6 +93,8 @@
#include "jit/Ion.h"
#endif
+#include "starboard/file.h"
+
using namespace js;
using namespace js::gc;
using namespace js::types;
@@ -5119,6 +5121,27 @@
return script;
}
+#if defined(STARBOARD)
+JSScript *
+JS::Compile(JSContext *cx, HandleObject obj, CompileOptions options,
+ SbFile file)
+{
+ SbFileInfo info;
+ bool success = SbFileGetInfo(file, &info);
+ if (!success) {
+ return NULL;
+ }
+ const int64_t kFileSize = info.size;
+ FileContents buffer(cx);
+ buffer.resize(kFileSize);
+ if (SbFileRead(file, buffer.begin(), kFileSize) < 0) {
+ return NULL;
+ }
+ JSScript *script = Compile(cx, obj, options, buffer.begin(),
+ buffer.length());
+ return script;
+}
+#else
JSScript *
JS::Compile(JSContext *cx, HandleObject obj, CompileOptions options, FILE *fp)
{
@@ -5129,15 +5152,26 @@
JSScript *script = Compile(cx, obj, options, buffer.begin(), buffer.length());
return script;
}
+#endif
JSScript *
JS::Compile(JSContext *cx, HandleObject obj, CompileOptions options, const char *filename)
{
+#if defined(STARBOARD)
+ starboard::ScopedFile file(filename, kSbFileOpenOnly | kSbFileRead, NULL,
+ NULL);
+ if (!file.IsValid()) {
+ return NULL;
+ }
+ options = options.setFileAndLine(filename, 1);
+ JSScript *script = Compile(cx, obj, options, file.file());
+#else
AutoFile file;
if (!file.open(cx, filename))
return NULL;
options = options.setFileAndLine(filename, 1);
JSScript *script = Compile(cx, obj, options, file.fp());
+#endif
return script;
}
@@ -7082,4 +7116,3 @@
return JSObject::preventExtensions(cx, obj);
}
-
diff --git a/src/third_party/mozjs/js/src/jsapi.h b/src/third_party/mozjs/js/src/jsapi.h
index 9fb1cec..768260e 100644
--- a/src/third_party/mozjs/js/src/jsapi.h
+++ b/src/third_party/mozjs/js/src/jsapi.h
@@ -31,6 +31,8 @@
#include "js/Value.h"
#include "js/Vector.h"
+#include "starboard/file.h"
+
/************************************************************************/
namespace JS {
@@ -3990,8 +3992,14 @@
Compile(JSContext *cx, JS::Handle<JSObject*> obj, CompileOptions options,
const jschar *chars, size_t length);
+#if defined(STARBOARD)
+extern JS_PUBLIC_API(JSScript *)
+Compile(JSContext *cx, JS::Handle<JSObject*> obj, CompileOptions options,
+ SbFile file);
+#else
extern JS_PUBLIC_API(JSScript *)
Compile(JSContext *cx, JS::Handle<JSObject*> obj, CompileOptions options, FILE *file);
+#endif
extern JS_PUBLIC_API(JSScript *)
Compile(JSContext *cx, JS::Handle<JSObject*> obj, CompileOptions options, const char *filename);
diff --git a/src/third_party/mozjs/js/src/jsstarboard-time.cpp b/src/third_party/mozjs/js/src/jsstarboard-time.cpp
index bed499f..d5049e2 100644
--- a/src/third_party/mozjs/js/src/jsstarboard-time.cpp
+++ b/src/third_party/mozjs/js/src/jsstarboard-time.cpp
@@ -17,11 +17,11 @@
#include "mozilla/Assertions.h"
#include "unicode/timezone.h"
-SbTime get_dst_offset(SbTime utc_time) {
+SbTime getDSTOffset(int64_t utc_time_us) {
// UDate is in milliseconds from the epoch.
- UDate udate = utc_time / kSbTimeMillisecond;
+ UDate udate = utc_time_us / kSbTimeMillisecond;
- icu_46::TimeZone* current_zone = icu_46::TimeZone::createDefault();
+ icu::TimeZone* current_zone = icu::TimeZone::createDefault();
int32_t raw_offset_ms, dst_offset_ms;
UErrorCode error_code = U_ZERO_ERROR;
current_zone->getOffset(
@@ -30,7 +30,15 @@
if (U_SUCCESS(error_code)) {
MOZ_ASSERT(dst_offset_ms >= 0);
- return (raw_offset_ms + dst_offset_ms) * kSbTimeMillisecond;
+ return dst_offset_ms * kSbTimeMillisecond;
}
return 0;
}
+
+SbTime getTZOffset() {
+ icu::TimeZone* current_zone = icu::TimeZone::createDefault();
+ int32_t raw_offset_ms = current_zone->getRawOffset();
+ delete current_zone;
+ return raw_offset_ms * kSbTimeMillisecond;
+}
+
diff --git a/src/third_party/mozjs/js/src/jsstarboard-time.h b/src/third_party/mozjs/js/src/jsstarboard-time.h
index 0d20ad7..038dd2d 100644
--- a/src/third_party/mozjs/js/src/jsstarboard-time.h
+++ b/src/third_party/mozjs/js/src/jsstarboard-time.h
@@ -18,10 +18,14 @@
#include "starboard/time.h"
/*
- * Get the local time offset with DST applied using the current system's
- * timezone such that:
- * local_time = utc_time + get_dst_offset(utc_time)
+ * Get the DST offset at the given time. |utc_time_us| is relative to the posix
+ * epoch.
*/
-SbTime get_dst_offset(SbTime utc_time);
+SbTime getDSTOffset(int64_t utc_time_us);
+
+/*
+ * Get the TZ offset based on the system's current timezone setting.
+ */
+SbTime getTZOffset();
#endif // jsstarboardtime_h
diff --git a/src/third_party/mozjs/js/src/prmjtime.cpp b/src/third_party/mozjs/js/src/prmjtime.cpp
index 12b2f40..c1e67b5 100644
--- a/src/third_party/mozjs/js/src/prmjtime.cpp
+++ b/src/third_party/mozjs/js/src/prmjtime.cpp
@@ -193,11 +193,11 @@
int64_t
PRMJ_Now(void)
{
- // SbTime is in microseconds since the epoch.
- SbTime utcNowMicroseconds = SbTimeGetNow();
- SbTime dstOffsetMicroseconds = get_dst_offset(utcNowMicroseconds);
- return utcNowMicroseconds + dstOffsetMicroseconds;
+ // SbTime is in microseconds since the Starboard/Windows epoch, and PRMJ_Now
+ // should return microseconds since the Posix epoch.
+ return SbTimeToPosix(SbTimeGetNow());
}
+
#elif defined(XP_OS2)
int64_t
PRMJ_Now(void)
diff --git a/src/third_party/mozjs/js/src/shell/js.cpp b/src/third_party/mozjs/js/src/shell/js.cpp
index 7b1cf6b..4af5e8d 100644
--- a/src/third_party/mozjs/js/src/shell/js.cpp
+++ b/src/third_party/mozjs/js/src/shell/js.cpp
@@ -8,7 +8,9 @@
#include <errno.h>
#include <locale.h>
#include <math.h>
+#if !defined(STARBOARD)
#include <signal.h>
+#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
@@ -72,7 +74,7 @@
# include <direct.h>
# include "jswin.h"
# define PATH_MAX (MAX_PATH > _MAX_DIR ? MAX_PATH : _MAX_DIR)
-#else
+#elif !defined(STARBOARD)
# include <libgen.h>
#endif
@@ -89,6 +91,8 @@
#include "zlib.h"
#endif
+#include "starboard/client_porting/wrap_main/wrap_main.h"
+
using namespace js;
using namespace js::cli;
@@ -413,6 +417,13 @@
}
static void
+#if defined(STARBOARD)
+RunFile(JSContext *cx, Handle<JSObject*> obj, const char *filename, SbFile file,
+ bool compileOnly)
+{
+ // We may not handle lines starting with # correctly without
+ // adding more here.
+#else
RunFile(JSContext *cx, Handle<JSObject*> obj, const char *filename, FILE *file, bool compileOnly)
{
SkipUTF8BOM(file);
@@ -427,6 +438,7 @@
}
}
ungetc(ch, file);
+#endif
int64_t t1 = PRMJ_Now();
uint32_t oldopts = JS_GetOptions(cx);
@@ -531,8 +543,7 @@
if (hitEOF && buffer.empty())
break;
- if (!EvalAndPrint(cx, global, buffer.begin(), buffer.length(), startline, compileOnly,
- out))
+ if (!EvalAndPrint(cx, global, buffer.begin(), buffer.length(), startline, compileOnly, out))
{
// Catch the error, report it, and keep going.
JS_ReportPendingException(cx);
@@ -554,11 +565,31 @@
}
};
+#if defined(STARBOARD)
+static void
+Process(JSContext *cx, JSObject *obj_, const char *filename, bool forceTTY)
+{
+ // No interactive mode for Starboard : stdin not guaranteed.
+ if (forceTTY) {
+ return;
+ }
+ RootedObject obj(cx, obj_);
+ SbFile file = SbFileOpen(filename, kSbFileOpenOnly | kSbFileRead, NULL,
+ NULL);
+ if (!SbFileIsValid(file)) {
+ SbFileClose(file);
+ return;
+ }
+
+ SetContextOptions(cx);
+ RunFile(cx, obj, filename, file, compileOnly);
+ SbFileClose(file);
+}
+#else
static void
Process(JSContext *cx, JSObject *obj_, const char *filename, bool forceTTY)
{
RootedObject obj(cx, obj_);
-
FILE *file;
if (forceTTY || !filename || strcmp(filename, "-") == 0) {
file = stdin;
@@ -572,9 +603,7 @@
}
}
AutoCloseInputFile autoClose(file);
-
SetContextOptions(cx);
-
if (!forceTTY && !isatty(fileno(file))) {
// It's not interactive - just execute it.
RunFile(cx, obj, filename, file, compileOnly);
@@ -583,6 +612,7 @@
ReadEvalPrintLoop(cx, obj, file, gOutFile, compileOnly);
}
}
+#endif // STARBOARD
/*
* JSContext option name to flag map. The option names are in alphabetical
@@ -706,22 +736,37 @@
static char buffer[PATH_MAX+1];
if (scriptRelative) {
-#ifdef XP_WIN
+#if defined(STARBOARD)
+ // We do not expect relative path scripts to work in Starboard.
+ return NULL;
+#elif defined(XP_WIN)
// The docs say it can return EINVAL, but the compiler says it's void
_splitpath(script->filename(), NULL, buffer, NULL, NULL);
#else
strncpy(buffer, script->filename(), PATH_MAX+1);
if (buffer[PATH_MAX] != '\0')
return NULL;
-
// dirname(buffer) might return buffer, or it might return a
// statically-allocated string
memmove(buffer, dirname(buffer), strlen(buffer) + 1);
#endif
} else {
+#if defined(STARBOARD)
+ // For Starboard, the tests scripts are in
+ // content/dir_source_root/mozjs/tests
+ // so we let that play the role of the cwd.
+ bool result = SbSystemGetPath(kSbSystemPathSourceDirectory,
+ buffer, PATH_MAX + 1);
+ if (!result) {
+ return NULL;
+ }
+ // Append subdirectory /mozjs/tests.
+ SbStringConcat(buffer, "/mozjs/tests", PATH_MAX + 1);
+#else
const char *cwd = getcwd(buffer, PATH_MAX);
if (!cwd)
return NULL;
+#endif
}
size_t len = strlen(buffer);
@@ -771,7 +816,7 @@
}
}
if (!found)
- names = js_strdup("");
+ names = js_strdup((char*)"");
if (!names) {
JS_ReportOutOfMemory(cx);
return false;
@@ -2987,7 +3032,9 @@
static bool
ScheduleWatchdog(JSRuntime *rt, double t)
{
-#ifdef XP_WIN
+#if defined(STARBOARD)
+ return (t <= 0);
+#elif defined(XP_WIN)
if (gTimerHandle) {
DeleteTimerQueueTimer(NULL, gTimerHandle, NULL);
gTimerHandle = 0;
@@ -3311,6 +3358,7 @@
return ReadFile(cx, argc, vp, true);
}
+#if !defined(STARBOARD)
static JSBool
System(JSContext *cx, unsigned argc, jsval *vp)
{
@@ -3334,6 +3382,7 @@
JS_SET_RVAL(cx, vp, Int32Value(result));
return true;
}
+#endif
static bool
DecompileFunctionSomehow(JSContext *cx, unsigned argc, Value *vp,
@@ -3885,11 +3934,11 @@
JS_FN_HELP("setThrowHook", SetThrowHook, 1, 0,
"setThrowHook(f)",
" Set throw hook to f."),
-
+#if !defined(STARBOARD)
JS_FN_HELP("system", System, 1, 0,
"system(command)",
" Execute command on the current host, returning result code."),
-
+#endif
JS_FN_HELP("trap", Trap, 3, 0,
"trap([fun, [pc,]] exp)",
" Trap bytecode execution."),
@@ -4450,6 +4499,8 @@
JS_smprintf_free(waste);
#endif
}
+#elif defined(STARBOARD)
+ rv = -1;
#else
rv = setenv(idstr.getBytes(), valstr.getBytes(), 1);
#endif
@@ -4502,6 +4553,7 @@
return false;
name = idstr.getBytes();
+#if !defined(STARBOARD)
value = getenv(name);
if (value) {
valstr = JS_NewStringCopyZ(cx, value);
@@ -4513,6 +4565,7 @@
}
objp.set(obj);
}
+#endif
return true;
}
@@ -5160,10 +5213,14 @@
FILE* defaultOut,
FILE** outFile)
{
+#if defined(STARBOARD)
+ *outFile = defaultOut;
+#else
const char* outPath = getenv(envVar);
if (!outPath || !*outPath || !(*outFile = fopen(outPath, "w"))) {
*outFile = defaultOut;
}
+#endif
}
/* Set the initial counter to 1 so the principal will never be destroyed. */
@@ -5189,7 +5246,7 @@
}
int
-main(int argc, char **argv, char **envp)
+ShellMain(int argc, char **argv, char **envp)
{
int stackDummy;
JSRuntime *rt;
@@ -5382,7 +5439,6 @@
/* Must be done before creating the global object */
if (op.getBoolOption('D'))
JS_ToggleOptions(cx, JSOPTION_PCCOUNT);
-
result = Shell(cx, &op, envp);
#if defined(DEBUG) && !defined(JS_USE_CUSTOM_ALLOCATOR)
@@ -5401,3 +5457,9 @@
JS_ShutDown();
return result;
}
+
+int ShellMainNoEnv(int argc, char** argv) {
+ return ShellMain(argc, argv, NULL);
+}
+
+STARBOARD_WRAP_SIMPLE_MAIN(ShellMainNoEnv);
diff --git a/src/third_party/mozjs/js/src/shell/jsoptparse.cpp b/src/third_party/mozjs/js/src/shell/jsoptparse.cpp
index 204efa1..18be826 100644
--- a/src/third_party/mozjs/js/src/shell/jsoptparse.cpp
+++ b/src/third_party/mozjs/js/src/shell/jsoptparse.cpp
@@ -253,7 +253,7 @@
char *eq = strchr(argv[*i], '=');
if (eq) {
*value = eq + 1;
- if (value[0] == '\0')
+ if (*value[0] == '\0')
return error("A value is required for option %.*s", eq - argv[*i], argv[*i]);
return Okay;
}
diff --git a/src/third_party/mozjs/js/src/vm/DateTime.cpp b/src/third_party/mozjs/js/src/vm/DateTime.cpp
index 9c26bd9..cfca247 100644
--- a/src/third_party/mozjs/js/src/vm/DateTime.cpp
+++ b/src/third_party/mozjs/js/src/vm/DateTime.cpp
@@ -17,16 +17,7 @@
using mozilla::UnspecifiedNaN;
-#if defined(STARBOARD)
-static int32_t
-UTCToLocalStandardOffsetSeconds()
-{
- SbTimeZone timeZone = SbTimeZoneGetCurrent();
- // timeZone is in minutes
- return timeZone * 60;
-}
-
-#else
+#if !defined(STARBOARD)
static bool
ComputeLocalTime(time_t local, struct tm *ptm)
{
@@ -149,7 +140,11 @@
* The difference between local standard time and UTC will never change for
* a given time zone.
*/
+#if defined(STARBOARD)
+ utcToLocalStandardOffsetSeconds = getTZOffset() / kSbTimeSecond;
+#else
utcToLocalStandardOffsetSeconds = UTCToLocalStandardOffsetSeconds();
+#endif
double newTZA = utcToLocalStandardOffsetSeconds * msPerSecond;
if (newTZA == localTZA_)
@@ -192,7 +187,7 @@
MOZ_ASSERT(utcSeconds <= MaxUnixTimeT);
SbTime utcTimeMicroseconds = utcSeconds * kSbTimeSecond;
- SbTime offsetMicroseconds = get_dst_offset(utcTimeMicroseconds);
+ SbTime offsetMicroseconds = getDSTOffset(utcTimeMicroseconds);
return offsetMicroseconds / kSbTimeMillisecond;
}
diff --git a/src/third_party/mozjs/mozjs.gyp b/src/third_party/mozjs/mozjs.gyp
index c646032..b0c4497 100644
--- a/src/third_party/mozjs/mozjs.gyp
+++ b/src/third_party/mozjs/mozjs.gyp
@@ -205,7 +205,30 @@
'mozjs_lib',
'<(DEPTH)/starboard/starboard.gyp:starboard',
'<(DEPTH)/third_party/zlib/zlib.gyp:zlib',
- ]
+ ],
+ 'actions': [
+ {
+ 'action_name': 'copy_test_data',
+ 'variables': {
+ 'input_files': [
+ 'js/src/tests/',
+ ],
+ 'output_dir': 'mozjs/tests/',
+ },
+ 'includes': ['../../starboard/build/copy_test_data.gypi'],
+ },
+ ],
+ },
+ {
+ 'target_name': 'mozjs_shell_deploy',
+ 'type': 'none',
+ 'dependencies': [
+ 'mozjs_shell',
+ ],
+ 'variables': {
+ 'executable_name': 'mozjs_shell',
+ },
+ 'includes': [ '../../starboard/build/deploy.gypi' ],
},
{
# SpiderMonkey source expects to include files from a certain directory
