components/html_viewer/stats_collection_controller.cc

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "components/html_viewer/stats_collection_controller.h"
   6
   7 #include "base/command_line.h"
   8 #include "base/memory/scoped_ptr.h"
   9 #include "base/metrics/histogram.h"
  10 #include "base/metrics/statistics_recorder.h"
  11 #include "base/time/time.h"
  12 #include "components/startup_metric_utils/startup_metric_utils.h"
  13 #include "gin/handle.h"
  14 #include "gin/object_template_builder.h"
  15 #include "mojo/application/public/cpp/application_impl.h"
  16 #include "mojo/services/tracing/public/cpp/switches.h"
  17 #include "third_party/WebKit/public/web/WebKit.h"
  18 #include "third_party/WebKit/public/web/WebLocalFrame.h"
  19
  20 namespace html_viewer {
  21
  22 namespace {
  23
  24 // Initialize the histogram data using the given startup performance times.
  25 // TODO(msw): Use TimeTicks to avoid system clock changes: crbug.com/521164
  26 void GetStartupPerformanceTimesCallbackImpl(
  27     tracing::StartupPerformanceTimesPtr times) {
  28   base::StatisticsRecorder::Initialize();
  29
  30   startup_metric_utils::RecordStartupProcessCreationTime(
  31       base::Time::FromInternalValue(times->shell_process_creation_time));
  32
  33   // TODO(msw): Record the MojoMain() entry point time of mojo:browser instead?
  34   startup_metric_utils::RecordMainEntryPointTime(
  35       base::Time::FromInternalValue(times->shell_main_entry_point_time));
  36
  37   // TODO(msw): Determine if this is the first run.
  38   startup_metric_utils::RecordBrowserMainMessageLoopStart(
  39       base::Time::FromInternalValue(times->browser_message_loop_start_time),
  40       false);
  41
  42   startup_metric_utils::RecordBrowserWindowDisplay(
  43       base::Time::FromInternalValue(times->browser_window_display_time));
  44
  45   startup_metric_utils::RecordBrowserOpenTabsDelta(
  46       base::TimeDelta::FromInternalValue(times->browser_open_tabs_time_delta));
  47
  48   startup_metric_utils::RecordFirstWebContentsMainFrameLoad(
  49       base::Time::FromInternalValue(
  50           times->first_web_contents_main_frame_load_time));
  51
  52   startup_metric_utils::RecordFirstWebContentsNonEmptyPaint(
  53       base::Time::FromInternalValue(
  54           times->first_visually_non_empty_layout_time));
  55 }
  56
  57 }  // namespace
  58
  59 // static
  60 gin::WrapperInfo StatsCollectionController::kWrapperInfo = {
  61     gin::kEmbedderNativeGin};
  62
  63 // static
  64 tracing::StartupPerformanceDataCollectorPtr StatsCollectionController::Install(
  65     blink::WebFrame* frame,
  66     mojo::ApplicationImpl* app) {
  67   // Only make startup tracing available when running in the context of a test.
  68   if (!app ||
  69       !base::CommandLine::ForCurrentProcess()->HasSwitch(
  70           tracing::kEnableStatsCollectionBindings)) {
  71     return nullptr;
  72   }
  73
  74   v8::Isolate* isolate = blink::mainThreadIsolate();
  75   v8::HandleScope handle_scope(isolate);
  76   v8::Local<v8::Context> context = frame->mainWorldScriptContext();
  77   if (context.IsEmpty())
  78     return nullptr;
  79
  80   v8::Context::Scope context_scope(context);
  81
  82   mojo::URLRequestPtr request(mojo::URLRequest::New());
  83   request->url = mojo::String::From("mojo:tracing");
  84   scoped_ptr<mojo::ApplicationConnection> connection =
  85       app->ConnectToApplication(request.Pass());
  86   if (!connection)
  87     return nullptr;
  88   tracing::StartupPerformanceDataCollectorPtr collector_for_controller;
  89   tracing::StartupPerformanceDataCollectorPtr collector_for_caller;
  90   connection->ConnectToService(&collector_for_controller);
  91   connection->ConnectToService(&collector_for_caller);
  92
  93   gin::Handle<StatsCollectionController> controller = gin::CreateHandle(
  94       isolate, new StatsCollectionController(collector_for_controller.Pass()));
  95   DCHECK(!controller.IsEmpty());
  96   v8::Local<v8::Object> global = context->Global();
  97   global->Set(gin::StringToV8(isolate, "statsCollectionController"),
  98               controller.ToV8());
  99   return collector_for_caller.Pass();
 100 }
 101
 102 // static
 103 tracing::StartupPerformanceDataCollectorPtr
 104 StatsCollectionController::ConnectToDataCollector(mojo::ApplicationImpl* app) {
 105   // Only make startup tracing available when running in the context of a test.
 106   if (!app ||
 107       !base::CommandLine::ForCurrentProcess()->HasSwitch(
 108           tracing::kEnableStatsCollectionBindings)) {
 109     return nullptr;
 110   }
 111
 112   mojo::URLRequestPtr request(mojo::URLRequest::New());
 113   request->url = mojo::String::From("mojo:tracing");
 114   tracing::StartupPerformanceDataCollectorPtr collector;
 115   app->ConnectToService(request.Pass(), &collector);
 116   return collector.Pass();
 117 }
 118
 119 StatsCollectionController::StatsCollectionController(
 120     tracing::StartupPerformanceDataCollectorPtr collector)
 121     : startup_performance_data_collector_(collector.Pass()) {}
 122
 123 StatsCollectionController::~StatsCollectionController() {}
 124
 125 gin::ObjectTemplateBuilder StatsCollectionController::GetObjectTemplateBuilder(
 126     v8::Isolate* isolate) {
 127   return gin::Wrappable<StatsCollectionController>::GetObjectTemplateBuilder(
 128              isolate)
 129       .SetMethod("getHistogram", &StatsCollectionController::GetHistogram)
 130       .SetMethod("getBrowserHistogram",
 131                  &StatsCollectionController::GetBrowserHistogram);
 132 }
 133
 134 std::string StatsCollectionController::GetHistogram(
 135     const std::string& histogram_name) {
 136   DCHECK(base::CommandLine::ForCurrentProcess()->HasSwitch(
 137       tracing::kEnableStatsCollectionBindings));
 138
 139   static bool startup_histogram_initialized = false;
 140   if (!startup_histogram_initialized) {
 141     // Get the startup performance times from the tracing service.
 142     auto callback = base::Bind(&GetStartupPerformanceTimesCallbackImpl);
 143     startup_performance_data_collector_->GetStartupPerformanceTimes(callback);
 144     startup_performance_data_collector_.WaitForIncomingResponse();
 145     DCHECK(base::StatisticsRecorder::IsActive());
 146     startup_histogram_initialized = true;
 147   }
 148
 149   std::string histogram_json = "{}";
 150   base::HistogramBase* histogram =
 151       base::StatisticsRecorder::FindHistogram(histogram_name);
 152   if (histogram)
 153     histogram->WriteJSON(&histogram_json);
 154   return histogram_json;
 155 }
 156
 157 std::string StatsCollectionController::GetBrowserHistogram(
 158     const std::string& histogram_name) {
 159   return GetHistogram(histogram_name);
 160 }
 161
 162 }  // namespace html_viewer