Import Cobalt 3.12305
diff --git a/src/cobalt/base/deep_link_event.h b/src/cobalt/base/deep_link_event.h index 5e3df4b..b5c2afa 100644 --- a/src/cobalt/base/deep_link_event.h +++ b/src/cobalt/base/deep_link_event.h
@@ -20,6 +20,7 @@ #include <string> #include "base/compiler_specific.h" +#include "base/string_util.h" #include "cobalt/base/event.h" namespace base { @@ -28,6 +29,9 @@ public: explicit DeepLinkEvent(const std::string& link) : link_(link) {} const std::string& link() const { return link_; } + bool IsH5vccLink() const { + return StartsWithASCII(link_, "h5vcc", true); + } BASE_EVENT_SUBCLASS(DeepLinkEvent);
diff --git a/src/cobalt/browser/application.cc b/src/cobalt/browser/application.cc index 27c9f1a..b6e58dc 100644 --- a/src/cobalt/browser/application.cc +++ b/src/cobalt/browser/application.cc
@@ -430,6 +430,10 @@ base::Bind(&Application::OnApplicationEvent, base::Unretained(this)); event_dispatcher_.AddEventCallback(system_window::ApplicationEvent::TypeId(), application_event_callback_); + deep_link_event_callback_ = + base::Bind(&Application::OnDeepLinkEvent, base::Unretained(this)); + event_dispatcher_.AddEventCallback(base::DeepLinkEvent::TypeId(), + deep_link_event_callback_); #if defined(ENABLE_WEBDRIVER) #if defined(ENABLE_DEBUG_COMMAND_LINE_SWITCHES) @@ -479,6 +483,8 @@ network_event_callback_); event_dispatcher_.RemoveEventCallback( system_window::ApplicationEvent::TypeId(), application_event_callback_); + event_dispatcher_.RemoveEventCallback( + base::DeepLinkEvent::TypeId(), deep_link_event_callback_); app_status_ = kShutDownAppStatus; } @@ -551,6 +557,15 @@ } } +void Application::OnDeepLinkEvent(const base::Event* event) { + const base::DeepLinkEvent* deep_link_event = + base::polymorphic_downcast<const base::DeepLinkEvent*>(event); + // TODO: Remove this when terminal application states are properly handled. + if (deep_link_event->IsH5vccLink()) { + browser_module_->Navigate(GURL(deep_link_event->link())); + } +} + void Application::WebModuleRecreated() { #if defined(ENABLE_WEBDRIVER) if (web_driver_module_) {
diff --git a/src/cobalt/browser/application.h b/src/cobalt/browser/application.h index 3b5189a..d3a1f9f 100644 --- a/src/cobalt/browser/application.h +++ b/src/cobalt/browser/application.h
@@ -67,6 +67,9 @@ // Called to handle an application event. void OnApplicationEvent(const base::Event* event); + // Called to handle a deep link event. + void OnDeepLinkEvent(const base::Event* event); + // Called when a navigation occurs in the BrowserModule. void WebModuleRecreated(); @@ -88,6 +91,7 @@ base::EventCallback account_event_callback_; base::EventCallback network_event_callback_; base::EventCallback application_event_callback_; + base::EventCallback deep_link_event_callback_; // Thread checkers to ensure that callbacks for network and application events // always occur on the same thread.
diff --git a/src/cobalt/browser/browser_module.cc b/src/cobalt/browser/browser_module.cc index da20704..7949da2 100644 --- a/src/cobalt/browser/browser_module.cc +++ b/src/cobalt/browser/browser_module.cc
@@ -21,11 +21,13 @@ #include "base/bind.h" #include "base/command_line.h" #include "base/debug/trace_event.h" +#include "base/lazy_instance.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 "base/time.h" #include "cobalt/base/cobalt_paths.h" #include "cobalt/base/source_location.h" #include "cobalt/base/tokens.h" @@ -36,11 +38,70 @@ #include "cobalt/dom/keycode.h" #include "cobalt/h5vcc/h5vcc.h" #include "cobalt/input/input_device_manager_fuzzer.h" +#include "starboard/atomic.h" +#include "starboard/system.h" +#include "starboard/time.h" + +#if defined(OS_STARBOARD) +#include "starboard/configuration.h" +#if SB_HAS(CORE_DUMP_HANDLER_SUPPORT) +#define HANDLE_CORE_DUMP +#include "starboard/ps4/core_dump_handler.h" +#endif // SB_HAS(CORE_DUMP_HANDLER_SUPPORT) +#endif // OS_STARBOARD namespace cobalt { + +#if defined(COBALT_CHECK_SUBMITDONE_TIMEOUT) +namespace timestamp { +// This is a temporary workaround. +extern SbAtomic64 g_last_submit_done_timestamp; +} // namespace timestamp + +namespace { +struct NonTrivialGlobalVariables { + NonTrivialGlobalVariables(); + + SbAtomic64* last_submit_done_timestamp; +}; + +NonTrivialGlobalVariables::NonTrivialGlobalVariables() { + last_submit_done_timestamp = &cobalt::timestamp::g_last_submit_done_timestamp; + SbAtomicNoBarrier_Exchange64(last_submit_done_timestamp, + static_cast<SbAtomic64>(SbTimeGetNow())); +} + +base::LazyInstance<NonTrivialGlobalVariables> non_trivial_global_variables = + LAZY_INSTANCE_INITIALIZER; + +} // namespace +#endif + namespace browser { namespace { +#if defined(COBALT_CHECK_SUBMITDONE_TIMEOUT) +// Timeout for last submitDone(). +const int kLastSubmitDoneTimeoutSeconds = 15; + +// Polling interval for timeout_polling_thread_. +const int kRenderTimeOutPollingDelaySeconds = 1; + +// Minimum number of continuous times the timeout expirations. This is used to +// prevent unintended behavior in situations such as when returning from +// suspended state. Note that the timeout response trigger will be delayed +// after the actual timeout expiration by this value times the polling delay. +const int kMinimumContinuousRenderTimeoutExpirations = 2; + +// Name for timeout_polling_thread_. +const char* kTimeoutPollingThreadName = "TimeoutPolling"; + +// This specifies the percentage of calls to OnRenderTimeout() that result in a +// call to OnError(). +const int kRenderTimeoutErrorPercentage = 99; + +#endif + // This constant defines the maximum rate at which the layout engine will // refresh over time. Since there is little benefit in performing a layout // faster than the display's refresh rate, we set this to 60Hz. @@ -165,7 +226,25 @@ h5vcc_url_handler_(this, system_window, account_manager)), web_module_options_(options.web_module_options), has_resumed_(true, false), +#if defined(COBALT_CHECK_SUBMITDONE_TIMEOUT) + timeout_polling_thread_(kTimeoutPollingThreadName), + render_timeout_count_(0), +#endif will_quit_(false) { +#if defined(HANDLE_CORE_DUMP) + on_error_triggered_count_ = 0; + recovery_mechanism_triggered_count_ = 0; + submit_done_timeout_count_ = 0; + SbCoreDumpRegisterHandler(BrowserModule::CoreDumpHandler, this); +#endif +#if defined(COBALT_CHECK_SUBMITDONE_TIMEOUT) + timeout_polling_thread_.Start(); + timeout_polling_thread_.message_loop()->PostDelayedTask( + FROM_HERE, base::Bind(&BrowserModule::OnPollForRenderTimeout, + base::Unretained(this), url), + base::TimeDelta::FromSeconds(kRenderTimeOutPollingDelaySeconds)); +#endif + // Setup our main web module to have the H5VCC API injected into it. DCHECK(!ContainsKey(web_module_options_.injected_window_attributes, "h5vcc")); h5vcc::H5vcc::Settings h5vcc_settings; @@ -211,6 +290,9 @@ BrowserModule::~BrowserModule() { DCHECK_EQ(MessageLoop::current(), self_message_loop_); +#if defined(HANDLE_CORE_DUMP) + SbCoreDumpUnregisterHandler(BrowserModule::CoreDumpHandler, this); +#endif } void BrowserModule::Navigate(const GURL& url) { @@ -227,6 +309,20 @@ base::SourceLocation("[object BrowserModule]", 1, 1)); } +#if defined(HANDLE_CORE_DUMP) +// static +void BrowserModule::CoreDumpHandler(void* browser_module_as_void) { + BrowserModule* browser_module = + static_cast<BrowserModule*>(browser_module_as_void); + SbCoreDumpLogInteger("BrowserModule.on_error_triggered_count_", + browser_module->on_error_triggered_count_); + SbCoreDumpLogInteger("BrowserModule.recovery_mechanism_triggered_count_", + browser_module->recovery_mechanism_triggered_count_); + SbCoreDumpLogInteger("BrowserModule.submit_done_timeout_count_", + browser_module->submit_done_timeout_count_); +} +#endif + void BrowserModule::NavigateInternal(const GURL& url) { DCHECK_EQ(MessageLoop::current(), self_message_loop_); @@ -454,6 +550,9 @@ } void BrowserModule::OnError(const GURL& url, const std::string& error) { +#if defined(HANDLE_CORE_DUMP) + on_error_triggered_count_++; +#endif LOG(ERROR) << error; std::string url_string = "h5vcc://network-failure"; @@ -610,5 +709,52 @@ } #endif // OS_STARBOARD +#if defined(COBALT_CHECK_SUBMITDONE_TIMEOUT) +void BrowserModule::OnPollForRenderTimeout(const GURL& url) { + SbTime last_submitdone_timestamp = static_cast<SbTime>(SbAtomicAcquire_Load64( + non_trivial_global_variables.Get().last_submit_done_timestamp)); + base::Time last_submitdone = + base::Time::FromSbTime(last_submitdone_timestamp); + bool timeout_expiration = + base::Time::Now() - + base::TimeDelta::FromSeconds(kLastSubmitDoneTimeoutSeconds) > + last_submitdone; + bool timeout_response_trigger = false; + if (timeout_expiration) { + // The timeout only triggers if the timeout expiration has been detected + // without interruption at least kMinimumContinuousRenderTimeoutExpirations + // times. + ++render_timeout_count_; + timeout_response_trigger = + render_timeout_count_ >= kMinimumContinuousRenderTimeoutExpirations; + } else { + render_timeout_count_ = 0; + } + + if (timeout_response_trigger) { +#if defined(HANDLE_CORE_DUMP) + submit_done_timeout_count_++; +#endif + SbAtomicNoBarrier_Exchange64( + non_trivial_global_variables.Get().last_submit_done_timestamp, + static_cast<SbAtomic64>(kSbTimeMax)); + if (SbSystemGetRandomUInt64() < + kRenderTimeoutErrorPercentage * (UINT64_MAX / 100)) { + OnError(url, std::string("Rendering Timeout")); +#if defined(HANDLE_CORE_DUMP) + recovery_mechanism_triggered_count_++; +#endif + } else { + SB_DLOG(INFO) << "Received OnRenderTimeout, ignoring by random chance."; + } + } else { + timeout_polling_thread_.message_loop()->PostDelayedTask( + FROM_HERE, base::Bind(&BrowserModule::OnPollForRenderTimeout, + base::Unretained(this), url), + base::TimeDelta::FromSeconds(kRenderTimeOutPollingDelaySeconds)); + } +} +#endif + } // namespace browser } // namespace cobalt
diff --git a/src/cobalt/browser/browser_module.h b/src/cobalt/browser/browser_module.h index d00a3fb..5d39973 100644 --- a/src/cobalt/browser/browser_module.h +++ b/src/cobalt/browser/browser_module.h
@@ -23,6 +23,7 @@ #include "base/memory/scoped_ptr.h" #include "base/synchronization/lock.h" #include "base/synchronization/waitable_event.h" +#include "base/threading/thread.h" #include "cobalt/account/account_manager.h" #include "cobalt/base/message_queue.h" #include "cobalt/browser/h5vcc_url_handler.h" @@ -48,6 +49,10 @@ #include "cobalt/debug/debug_server.h" #endif // ENABLE_DEBUG_CONSOLE +#if defined(OS_STARBOARD) +#include "starboard/configuration.h" +#endif + namespace cobalt { namespace browser { @@ -114,6 +119,15 @@ void SetProxy(const std::string& proxy_rules); private: +#if defined(OS_STARBOARD) +#if SB_HAS(CORE_DUMP_HANDLER_SUPPORT) + static void CoreDumpHandler(void* browser_module_as_void); + int on_error_triggered_count_; + int recovery_mechanism_triggered_count_; + int submit_done_timeout_count_; +#endif +#endif + // Recreates web module with the given URL. void NavigateInternal(const GURL& url); @@ -200,6 +214,11 @@ // Process all messages queued into the |render_tree_submission_queue_|. void ProcessRenderTreeSubmissionQueue(); +#if defined(COBALT_CHECK_SUBMITDONE_TIMEOUT) + // Poll for render timeout. Called from timeout_polling_thread_. + void OnPollForRenderTimeout(const GURL& url); +#endif + // TODO: // WeakPtr usage here can be avoided if BrowserModule has a thread to // own where it can ensure that its tasks are all resolved when it is @@ -316,6 +335,14 @@ // Reset when the browser is paused, signalled to resume. base::WaitableEvent has_resumed_; +#if defined(COBALT_CHECK_SUBMITDONE_TIMEOUT) + base::Thread timeout_polling_thread_; + + // Counts the number of continuous render timeout expirations. This value is + // updated and used from OnPollForRenderTimeout. + int render_timeout_count_; +#endif + // Set when the application is about to quit. May be set from a thread other // than the one hosting this object, and read from another. bool will_quit_;
diff --git a/src/cobalt/build/build.id b/src/cobalt/build/build.id index fa37d0f..f9b0452 100644 --- a/src/cobalt/build/build.id +++ b/src/cobalt/build/build.id
@@ -1 +1 @@ -11764 \ No newline at end of file +12305 \ No newline at end of file
diff --git a/src/cobalt/dom/node.cc b/src/cobalt/dom/node.cc index 59aed34..6ce2955 100644 --- a/src/cobalt/dom/node.cc +++ b/src/cobalt/dom/node.cc
@@ -37,6 +37,13 @@ #include "cobalt/dom/node_list_live.h" #include "cobalt/dom/rule_matching.h" #include "cobalt/dom/text.h" +#if defined(OS_STARBOARD) +#include "starboard/configuration.h" +#if SB_HAS(CORE_DUMP_HANDLER_SUPPORT) +#define HANDLE_CORE_DUMP +#include "starboard/ps4/core_dump_handler.h" +#endif // SB_HAS(CORE_DUMP_HANDLER_SUPPORT) +#endif // defined(OS_STARBOARD) namespace cobalt { namespace dom { @@ -49,8 +56,25 @@ NodeCountLog() : count(0) { base::UserLog::Register(base::UserLog::kNodeCountIndex, "NodeCnt", &count, sizeof(count)); +#if defined(HANDLE_CORE_DUMP) + SbCoreDumpRegisterHandler(CoreDumpHandler, this); +#endif } - ~NodeCountLog() { base::UserLog::Deregister(base::UserLog::kNodeCountIndex); } + + ~NodeCountLog() { +#if defined(HANDLE_CORE_DUMP) + SbCoreDumpUnregisterHandler(CoreDumpHandler, this); +#endif + base::UserLog::Deregister(base::UserLog::kNodeCountIndex); + } + +#if defined(HANDLE_CORE_DUMP) + static void CoreDumpHandler(void* context) { + SbCoreDumpLogInteger( + "Total number of nodes", + static_cast<NodeCountLog*>(context)->count); + } +#endif int count;
diff --git a/src/cobalt/dom_parser/libxml_html_parser_wrapper.cc b/src/cobalt/dom_parser/libxml_html_parser_wrapper.cc index 75e760b..968dbe5 100644 --- a/src/cobalt/dom_parser/libxml_html_parser_wrapper.cc +++ b/src/cobalt/dom_parser/libxml_html_parser_wrapper.cc
@@ -110,7 +110,7 @@ return; } - if (CheckInputAndUpdateSeverity(data, size) >= kError) { + if (CheckInputAndUpdateSeverity(data, size) == kFatal) { return; }
diff --git a/src/cobalt/dom_parser/libxml_parser_wrapper.cc b/src/cobalt/dom_parser/libxml_parser_wrapper.cc index ec05383..3550e78 100644 --- a/src/cobalt/dom_parser/libxml_parser_wrapper.cc +++ b/src/cobalt/dom_parser/libxml_parser_wrapper.cc
@@ -23,11 +23,81 @@ #include "cobalt/dom/comment.h" #include "cobalt/dom/element.h" #include "cobalt/dom/text.h" +#if defined(OS_STARBOARD) +#include "starboard/configuration.h" +#if SB_HAS(CORE_DUMP_HANDLER_SUPPORT) +#define HANDLE_CORE_DUMP +#include "base/lazy_instance.h" +#include "starboard/ps4/core_dump_handler.h" +#endif // SB_HAS(CORE_DUMP_HANDLER_SUPPORT) +#endif // defined(OS_STARBOARD) namespace cobalt { namespace dom_parser { namespace { +#if defined(HANDLE_CORE_DUMP) + +class LibxmlParserWrapperLog { + public: + LibxmlParserWrapperLog() + : total_parsed_bytes_(0), + total_warning_count_(0), + total_error_count_(0), + total_fatal_count_(0) { + SbCoreDumpRegisterHandler(CoreDumpHandler, this); + } + ~LibxmlParserWrapperLog() { + SbCoreDumpUnregisterHandler(CoreDumpHandler, this); + } + + static void CoreDumpHandler(void* context) { + SbCoreDumpLogInteger( + "LibxmlParserWrapper total parsed bytes", + static_cast<LibxmlParserWrapperLog*>(context)->total_parsed_bytes_); + SbCoreDumpLogInteger( + "LibxmlParserWrapper total warning count", + static_cast<LibxmlParserWrapperLog*>(context)->total_warning_count_); + SbCoreDumpLogInteger( + "LibxmlParserWrapper total error count", + static_cast<LibxmlParserWrapperLog*>(context)->total_error_count_); + SbCoreDumpLogInteger( + "LibxmlParserWrapper total fatal error count", + static_cast<LibxmlParserWrapperLog*>(context)->total_fatal_count_); + SbCoreDumpLogString("LibxmlParserWrapper last fatal error", + static_cast<LibxmlParserWrapperLog*>(context) + ->last_fatal_message_.c_str()); + } + + void IncrementParsedBytes(int length) { total_parsed_bytes_ += length; } + void LogParsingIssue(LibxmlParserWrapper::IssueSeverity severity, + const std::string& message) { + if (severity == LibxmlParserWrapper::kWarning) { + total_warning_count_++; + } else if (severity == LibxmlParserWrapper::kError) { + total_error_count_++; + } else if (severity == LibxmlParserWrapper::kFatal) { + total_fatal_count_++; + last_fatal_message_ = message; + } else { + NOTREACHED(); + } + } + + private: + int total_parsed_bytes_; + int total_warning_count_; + int total_error_count_; + int total_fatal_count_; + std::string last_fatal_message_; + DISALLOW_COPY_AND_ASSIGN(LibxmlParserWrapperLog); +}; + +base::LazyInstance<LibxmlParserWrapperLog> libxml_parser_wrapper_log = + LAZY_INSTANCE_INITIALIZER; + +#endif // defined(HANDLE_CORE_DUMP) + ///////////////////////////////////////////////////////////////////////////// // Helpers ///////////////////////////////////////////////////////////////////////////// @@ -214,16 +284,25 @@ void LibxmlParserWrapper::OnParsingIssue(IssueSeverity severity, const std::string& message) { + DCHECK(severity >= kWarning && severity <= kFatal); if (severity > max_severity_) { max_severity_ = severity; } if (severity < LibxmlParserWrapper::kFatal) { - LOG(WARNING) << message; - } else { + LOG(WARNING) << "Libxml " + << (severity == kWarning ? "Warning: " : "Error: ") << message; + } else if (severity == LibxmlParserWrapper::kFatal) { + LOG(ERROR) << "Libxml Fatal Error: " << message; if (!error_callback_.is_null()) { error_callback_.Run(message); } + } else { + NOTREACHED(); } + +#if defined(HANDLE_CORE_DUMP) + libxml_parser_wrapper_log.Get().LogParsingIssue(severity, message); +#endif } void LibxmlParserWrapper::OnCDATABlock(const std::string& value) { @@ -233,26 +312,30 @@ LibxmlParserWrapper::IssueSeverity LibxmlParserWrapper::CheckInputAndUpdateSeverity(const char* data, size_t size) { - if (max_severity_ >= kError) { + if (max_severity_ == kFatal) { return max_severity_; } // Check the total input size. total_input_size_ += size; if (total_input_size_ > kMaxTotalInputSize) { - static const char kErrorTooLong[] = "Parser input is too long."; - OnParsingIssue(kError, kErrorTooLong); + static const char kMessageInputTooLong[] = "Parser input is too long."; + OnParsingIssue(kFatal, kMessageInputTooLong); return max_severity_; } // Check the encoding of the input. if (!IsStringUTF8(std::string(data, size))) { - static const char kErrorNotUTF8[] = + static const char kMessageInputNotUTF8[] = "Parser input contains non-UTF8 characters."; - OnParsingIssue(kError, kErrorNotUTF8); + OnParsingIssue(kFatal, kMessageInputNotUTF8); return max_severity_; } +#if defined(HANDLE_CORE_DUMP) + libxml_parser_wrapper_log.Get().IncrementParsedBytes(static_cast<int>(size)); +#endif + return max_severity_; }
diff --git a/src/cobalt/dom_parser/libxml_parser_wrapper.h b/src/cobalt/dom_parser/libxml_parser_wrapper.h index c391fab..98d210e 100644 --- a/src/cobalt/dom_parser/libxml_parser_wrapper.h +++ b/src/cobalt/dom_parser/libxml_parser_wrapper.h
@@ -61,9 +61,9 @@ public: enum IssueSeverity { kNoIssue, - kWarning, - kError, - kFatal, + kWarning, // A simple warning + kError, // A recoverable error + kFatal, // A fatal error kIssueSeverityCount, }; @@ -137,8 +137,9 @@ } private: - // Maximum total input size, 1MB. - static const size_t kMaxTotalInputSize = 1 << 16; + // Maximum total input size, as specified in Libxml's value + // XML_MAX_TEXT_LENGTH in parserInternals.h. + static const size_t kMaxTotalInputSize = 10000000; const scoped_refptr<dom::Document> document_; const scoped_refptr<dom::Node> parent_node_;
diff --git a/src/cobalt/dom_parser/libxml_xml_parser_wrapper.cc b/src/cobalt/dom_parser/libxml_xml_parser_wrapper.cc index c933f5e..787970d 100644 --- a/src/cobalt/dom_parser/libxml_xml_parser_wrapper.cc +++ b/src/cobalt/dom_parser/libxml_xml_parser_wrapper.cc
@@ -79,7 +79,7 @@ return; } - if (CheckInputAndUpdateSeverity(data, size) >= kError) { + if (CheckInputAndUpdateSeverity(data, size) == kFatal) { return; }
diff --git a/src/cobalt/h5vcc/h5vcc_runtime.cc b/src/cobalt/h5vcc/h5vcc_runtime.cc index 8b0f871..e7e3748 100644 --- a/src/cobalt/h5vcc/h5vcc_runtime.cc +++ b/src/cobalt/h5vcc/h5vcc_runtime.cc
@@ -14,9 +14,10 @@ * limitations under the License. */ +#include "cobalt/h5vcc/h5vcc_runtime.h" + #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 { @@ -79,8 +80,10 @@ 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()); + if (!deep_link_event->IsH5vccLink()) { + 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/loader/net_fetcher.cc b/src/cobalt/loader/net_fetcher.cc index 4ba9d17..0f60e72 100644 --- a/src/cobalt/loader/net_fetcher.cc +++ b/src/cobalt/loader/net_fetcher.cc
@@ -21,12 +21,46 @@ #include "base/stringprintf.h" #include "cobalt/network/network_module.h" #include "net/url_request/url_fetcher.h" +#if defined(OS_STARBOARD) +#include "starboard/configuration.h" +#if SB_HAS(CORE_DUMP_HANDLER_SUPPORT) +#define HANDLE_CORE_DUMP +#include "base/lazy_instance.h" +#include "starboard/ps4/core_dump_handler.h" +#endif // SB_HAS(CORE_DUMP_HANDLER_SUPPORT) +#endif // OS_STARBOARD namespace cobalt { namespace loader { namespace { +#if defined(HANDLE_CORE_DUMP) + +class NetFetcherLog { + public: + NetFetcherLog() : total_fetched_bytes_(0) { + SbCoreDumpRegisterHandler(CoreDumpHandler, this); + } + ~NetFetcherLog() { SbCoreDumpUnregisterHandler(CoreDumpHandler, this); } + + static void CoreDumpHandler(void* context) { + SbCoreDumpLogInteger( + "NetFetcher total fetched bytes", + static_cast<NetFetcherLog*>(context)->total_fetched_bytes_); + } + + void IncrementFetchedBytes(int length) { total_fetched_bytes_ += length; } + + private: + int total_fetched_bytes_; + DISALLOW_COPY_AND_ASSIGN(NetFetcherLog); +}; + +base::LazyInstance<NetFetcherLog> net_fetcher_log = LAZY_INSTANCE_INITIALIZER; + +#endif // defined(HANDLE_CORE_DUMP) + bool IsResponseCodeSuccess(int response_code) { // NetFetcher only considers success to be if the network request // was successful *and* we get a 2xx response back. @@ -118,6 +152,10 @@ void NetFetcher::OnURLFetchDownloadData(const net::URLFetcher* source, scoped_ptr<std::string> download_data) { if (IsResponseCodeSuccess(source->GetResponseCode())) { +#if defined(HANDLE_CORE_DUMP) + net_fetcher_log.Get().IncrementFetchedBytes( + static_cast<int>(download_data->length())); +#endif handler()->OnReceived(this, download_data->data(), download_data->length()); } }
diff --git a/src/cobalt/script/script_runner.cc b/src/cobalt/script/script_runner.cc index d680966..3900885 100644 --- a/src/cobalt/script/script_runner.cc +++ b/src/cobalt/script/script_runner.cc
@@ -19,12 +19,51 @@ #include "base/logging.h" #include "cobalt/script/global_environment.h" #include "cobalt/script/source_code.h" +#if defined(OS_STARBOARD) +#include "starboard/configuration.h" +#if SB_HAS(CORE_DUMP_HANDLER_SUPPORT) +#define HANDLE_CORE_DUMP +#include "base/lazy_instance.h" +#include "starboard/ps4/core_dump_handler.h" +#endif // SB_HAS(CORE_DUMP_HANDLER_SUPPORT) +#endif // defined(OS_STARBOARD) namespace cobalt { namespace script { namespace { +#if defined(HANDLE_CORE_DUMP) + +class ScriptRunnerLog { + public: + ScriptRunnerLog() : success_count_(0), fail_count_(0) { + SbCoreDumpRegisterHandler(CoreDumpHandler, this); + } + ~ScriptRunnerLog() { SbCoreDumpUnregisterHandler(CoreDumpHandler, this); } + + static void CoreDumpHandler(void* context) { + SbCoreDumpLogInteger( + "ScriptRunner successful executions", + static_cast<ScriptRunnerLog*>(context)->success_count_); + SbCoreDumpLogInteger("ScriptRunner failed executions", + static_cast<ScriptRunnerLog*>(context)->fail_count_); + } + + void IncrementSuccessCount() { success_count_++; } + void IncrementFailCount() { fail_count_++; } + + private: + int success_count_; + int fail_count_; + DISALLOW_COPY_AND_ASSIGN(ScriptRunnerLog); +}; + +base::LazyInstance<ScriptRunnerLog> script_runner_log = + LAZY_INSTANCE_INITIALIZER; + +#endif // defined(HANDLE_CORE_DUMP) + class ScriptRunnerImpl : public ScriptRunner { public: explicit ScriptRunnerImpl( @@ -53,8 +92,14 @@ std::string result; if (!global_environment_->EvaluateScript(source_code, &result)) { DLOG(WARNING) << "Failed to execute JavaScript: " << result; +#if defined(HANDLE_CORE_DUMP) + script_runner_log.Get().IncrementFailCount(); +#endif return ""; } +#if defined(HANDLE_CORE_DUMP) + script_runner_log.Get().IncrementSuccessCount(); +#endif return result; }