Extract shell methods from ApplicationImpl into a base class, and pass this to Initialize() instead.

components/html_viewer/stats_collection_controller.cc

 // Copyright 2015 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 "components/html_viewer/stats_collection_controller.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/statistics_recorder.h"
 #include "base/time/time.h"
 #include "components/startup_metric_utils/browser/startup_metric_utils.h"
 #include "gin/handle.h"
 #include "gin/object_template_builder.h"
 #include "mojo/services/tracing/public/cpp/switches.h"
-#include "mojo/shell/public/cpp/application_impl.h"
+#include "mojo/shell/public/cpp/shell.h"
 #include "third_party/WebKit/public/web/WebKit.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 
 namespace html_viewer {
 
 namespace {
 
 // Initialize the histogram data using the given startup performance times.
 void GetStartupPerformanceTimesCallbackImpl(
     tracing::StartupPerformanceTimesPtr times) {
@@ skipping 30 matching lines @@
 
 }  // namespace
 
 // static
 gin::WrapperInfo StatsCollectionController::kWrapperInfo = {
     gin::kEmbedderNativeGin};
 
 // static
 tracing::StartupPerformanceDataCollectorPtr StatsCollectionController::Install(
     blink::WebFrame* frame,
-    mojo::ApplicationImpl* app) {
+    mojo::Shell* shell) {
   // Only make startup tracing available when running in the context of a test.
-  if (!app ||
+  if (!shell ||
       !base::CommandLine::ForCurrentProcess()->HasSwitch(
           tracing::kEnableStatsCollectionBindings)) {
     return nullptr;
   }
 
   v8::Isolate* isolate = blink::mainThreadIsolate();
   v8::HandleScope handle_scope(isolate);
   v8::Local<v8::Context> context = frame->mainWorldScriptContext();
   if (context.IsEmpty())
     return nullptr;
 
   v8::Context::Scope context_scope(context);
 
   scoped_ptr<mojo::ApplicationConnection> connection =
-      app->ConnectToApplication("mojo:tracing");
+      shell->ConnectToApplication("mojo:tracing");
   if (!connection)
     return nullptr;
   tracing::StartupPerformanceDataCollectorPtr collector_for_controller;
   tracing::StartupPerformanceDataCollectorPtr collector_for_caller;
   connection->ConnectToService(&collector_for_controller);
   connection->ConnectToService(&collector_for_caller);
 
   gin::Handle<StatsCollectionController> controller = gin::CreateHandle(
       isolate,
       new StatsCollectionController(std::move(collector_for_controller)));
   DCHECK(!controller.IsEmpty());
   v8::Local<v8::Object> global = context->Global();
   global->Set(gin::StringToV8(isolate, "statsCollectionController"),
               controller.ToV8());
   return collector_for_caller;
 }
 
 // static
 tracing::StartupPerformanceDataCollectorPtr
-StatsCollectionController::ConnectToDataCollector(mojo::ApplicationImpl* app) {
+StatsCollectionController::ConnectToDataCollector(mojo::Shell* shell) {
   // Only make startup tracing available when running in the context of a test.
-  if (!app ||
+  if (!shell ||
       !base::CommandLine::ForCurrentProcess()->HasSwitch(
           tracing::kEnableStatsCollectionBindings)) {
     return nullptr;
   }
 
   tracing::StartupPerformanceDataCollectorPtr collector;
-  app->ConnectToService("mojo:tracing", &collector);
+  shell->ConnectToService("mojo:tracing", &collector);
   return collector;
 }
 
 StatsCollectionController::StatsCollectionController(
     tracing::StartupPerformanceDataCollectorPtr collector)
     : startup_performance_data_collector_(std::move(collector)) {}
 
 StatsCollectionController::~StatsCollectionController() {}
 
 gin::ObjectTemplateBuilder StatsCollectionController::GetObjectTemplateBuilder(
@@ skipping 27 matching lines @@
     histogram->WriteJSON(&histogram_json);
   return histogram_json;
 }
 
 std::string StatsCollectionController::GetBrowserHistogram(
     const std::string& histogram_name) {
   return GetHistogram(histogram_name);
 }
 
 }  // namespace html_viewer