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
