Move ResourceUsageReporter to //content.

This is part of an effort to eliminate manifest overlays. (See bug).

This interface actually needs to be hooked up in some utility processes & renderers. At face value it seems like something like this could be part of the service manager API but it turns out to be very blink/v8 specific. Ultimately it should probably be exposed by the blink & proxy resolver services. Due to the way the task manager obtains these APIs currently moving to content makes the most sense.

http://crbug.com/810851

Change-Id: Ic7948d41487120d3207e96b866645854f7405b92
Reviewed-on: https://chromium-review.googlesource.com/887429
Reviewed-by: Tom Sepez <tsepez@chromium.org>
Reviewed-by: Ken Rockot <rockot@chromium.org>
Commit-Queue: Ben Goodger <ben@chromium.org>
Cr-Commit-Position: refs/heads/master@{#535868}

chrome/browser/chrome_content_gpu_manifest_overlay.json

@@ -9,7 +9,6 @@
           "arc::mojom::VideoDecodeClient",
           "arc::mojom::VideoEncodeAccelerator",
           "arc::mojom::VideoEncodeClient",
-          "chrome::mojom::ResourceUsageReporter",
           "profiling::mojom::ProfilingClient"
         ]
       }

chrome/browser/chrome_content_plugin_manifest_overlay.json

@@ -4,7 +4,6 @@
     "service_manager:connector": {
       "provides": {
         "browser": [
-          "chrome::mojom::ResourceUsageReporter"
         ]
       }
     }

chrome/browser/chrome_content_renderer_manifest_overlay.json

@@ -5,7 +5,6 @@
     "service_manager:connector": {
       "provides": {
         "browser": [
-          "chrome::mojom::ResourceUsageReporter",
           "chrome::mojom::SearchBouncer",
           "profiling::mojom::ProfilingClient"
         ]

chrome/browser/chrome_content_utility_manifest_overlay.json

@@ -6,7 +6,6 @@
         "browser": [
           "chrome::mojom::DialDeviceDescriptionParser",
           "chrome::mojom::ProfileImport",
-          "chrome::mojom::ResourceUsageReporter",
           "chrome::mojom::ShellHandler",
           "extensions::mojom::ExtensionUnpacker",
           "extensions::mojom::ManifestParser",

chrome/browser/process_resource_usage.cc

@@ -11,10 +11,10 @@
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
-#include "chrome/common/resource_usage_reporter_type_converters.h"
+#include "content/public/common/resource_usage_reporter_type_converters.h"
 
 ProcessResourceUsage::ProcessResourceUsage(
-    chrome::mojom::ResourceUsageReporterPtr service)
+    content::mojom::ResourceUsageReporterPtr service)
     : service_(std::move(service)), update_in_progress_(false) {
   service_.set_connection_error_handler(
       base::Bind(&ProcessResourceUsage::RunPendingRefreshCallbacks,
@@ -52,7 +52,7 @@ void ProcessResourceUsage::Refresh(const base::Closure& callback) {
 }
 
 void ProcessResourceUsage::OnRefreshDone(
-    chrome::mojom::ResourceUsageDataPtr data) {
+    content::mojom::ResourceUsageDataPtr data) {
   DCHECK(thread_checker_.CalledOnValidThread());
   update_in_progress_ = false;
   stats_ = std::move(data);

chrome/browser/process_resource_usage.h

@@ -11,20 +11,20 @@
 #include "base/containers/circular_deque.h"
 #include "base/macros.h"
 #include "base/threading/thread_checker.h"
-#include "chrome/common/resource_usage_reporter.mojom.h"
+#include "content/public/common/resource_usage_reporter.mojom.h"
 #include "third_party/WebKit/public/platform/WebCache.h"
 
 // Provides resource usage information about a child process.
 //
-// This is a wrapper around the chrome::mojom::ResourceUsageReporter Mojo
+// This is a wrapper around the content::mojom::ResourceUsageReporter Mojo
 // service that exposes
 // information about resources used by a child process. Currently, this is only
 // V8 memory and Blink resource cache usage, but could be expanded to include
 // other resources.  This is intended for status viewers such as the task
 // manager.
 //
 // To create:
-// 1. Create a chrome::mojom::ResourceUsageReporterPtr and obtain an
+// 1. Create a content::mojom::ResourceUsageReporterPtr and obtain an
 //    InterfaceRequest<>
 // using
 //    mojo::MakeRequest.
@@ -33,18 +33,18 @@
 //    must always be accessed from the same thread. However, InterfaceRequest<>
 //    can be passed safely between threads, and therefore a task can be posted
 //    to the ServiceRegistry thread to connect to the remote service.
-// 3. Pass the chrome::mojom::ResourceUsageReporterPtr to the constructor.
+// 3. Pass the content::mojom::ResourceUsageReporterPtr to the constructor.
 //
 // Example:
 //   void Foo::ConnectToService(
-//       mojo::InterfaceRequest<chrome::mojom::ResourceUsageReporter> req) {
+//       mojo::InterfaceRequest<content::mojom::ResourceUsageReporter> req) {
 //     content::ServiceRegistry* registry = host_->GetServiceRegistry();
 //     registry->ConnectToRemoteService(std::move(req));
 //   }
 //
 //   ...
-//     chrome::mojom::ResourceUsageReporterPtr service;
-//     mojo::InterfaceRequest<chrome::mojom::ResourceUsageReporter> request =
+//     content::mojom::ResourceUsageReporterPtr service;
+//     mojo::InterfaceRequest<content::mojom::ResourceUsageReporter> request =
 //         mojo::MakeRequest(&service);
 //     content::BrowserThread::PostTask(
 //         content::BrowserThread::IO, FROM_HERE,
@@ -58,7 +58,7 @@ class ProcessResourceUsage {
  public:
   // Must be called from the same thread that created |service|.
   explicit ProcessResourceUsage(
-      chrome::mojom::ResourceUsageReporterPtr service);
+      content::mojom::ResourceUsageReporterPtr service);
   ~ProcessResourceUsage();
 
   // Refresh the resource usage information. |callback| is invoked when the
@@ -75,15 +75,15 @@ class ProcessResourceUsage {
 
  private:
   // Mojo IPC callback.
-  void OnRefreshDone(chrome::mojom::ResourceUsageDataPtr data);
+  void OnRefreshDone(content::mojom::ResourceUsageDataPtr data);
 
   void RunPendingRefreshCallbacks();
 
-  chrome::mojom::ResourceUsageReporterPtr service_;
+  content::mojom::ResourceUsageReporterPtr service_;
   bool update_in_progress_;
   base::circular_deque<base::Closure> refresh_callbacks_;
 
-  chrome::mojom::ResourceUsageDataPtr stats_;
+  content::mojom::ResourceUsageDataPtr stats_;
 
   base::ThreadChecker thread_checker_;
 

chrome/browser/task_manager/providers/child_process_task.cc

@@ -113,7 +113,7 @@ base::string16 GetLocalizedTitle(const base::string16& title,
 // BrowserChildProcessHost whose unique ID is |unique_child_process_id|.
 void ConnectResourceReporterOnIOThread(
     int unique_child_process_id,
-    chrome::mojom::ResourceUsageReporterRequest resource_reporter) {
+    content::mojom::ResourceUsageReporterRequest resource_reporter) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   content::BrowserChildProcessHost* host =
@@ -129,7 +129,7 @@ void ConnectResourceReporterOnIOThread(
 // |unique_child_process_id|.
 ProcessResourceUsage* CreateProcessResourcesSampler(
     int unique_child_process_id) {
-  chrome::mojom::ResourceUsageReporterPtr usage_reporter;
+  content::mojom::ResourceUsageReporterPtr usage_reporter;
   content::BrowserThread::PostTask(
       content::BrowserThread::IO, FROM_HERE,
       base::BindOnce(&ConnectResourceReporterOnIOThread,

chrome/browser/task_manager/providers/web_contents/renderer_task.cc

@@ -33,7 +33,7 @@ namespace {
 // |render_process_host|.
 ProcessResourceUsage* CreateRendererResourcesSampler(
     content::RenderProcessHost* render_process_host) {
-  chrome::mojom::ResourceUsageReporterPtr service;
+  content::mojom::ResourceUsageReporterPtr service;
   BindInterface(render_process_host, &service);
   return new ProcessResourceUsage(std::move(service));
 }

chrome/common/BUILD.gn

@@ -168,8 +168,6 @@ static_library("common") {
     "profiling.h",
     "ref_counted_util.h",
     "render_messages.h",
-    "resource_usage_reporter_type_converters.cc",
-    "resource_usage_reporter_type_converters.h",
     "search/instant_types.cc",
     "search/instant_types.h",
     "search/ntp_logging_events.h",
@@ -669,7 +667,6 @@ mojom("mojo_bindings") {
     "plugin.mojom",
     "prerender.mojom",
     "renderer_configuration.mojom",
-    "resource_usage_reporter.mojom",
   ]
 
   if (is_win) {

chrome/renderer/chrome_render_thread_observer.cc

@@ -33,14 +33,13 @@
 #include "chrome/common/media/media_resource_provider.h"
 #include "chrome/common/net/net_resource_provider.h"
 #include "chrome/common/render_messages.h"
-#include "chrome/common/resource_usage_reporter.mojom.h"
-#include "chrome/common/resource_usage_reporter_type_converters.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/renderer/content_settings_observer.h"
 #include "chrome/renderer/security_filter_peer.h"
 #include "components/visitedlink/renderer/visitedlink_slave.h"
 #include "content/public/child/child_thread.h"
 #include "content/public/common/content_switches.h"
+#include "content/public/common/resource_usage_reporter_type_converters.h"
 #include "content/public/common/service_manager_connection.h"
 #include "content/public/common/service_names.mojom.h"
 #include "content/public/common/simple_connection_filter.h"
@@ -57,7 +56,6 @@
 #include "services/service_manager/public/cpp/binder_registry.h"
 #include "services/service_manager/public/cpp/connector.h"
 #include "third_party/WebKit/common/associated_interfaces/associated_interface_registry.h"
-#include "third_party/WebKit/public/platform/WebCache.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebSecurityPolicy.h"
@@ -135,110 +133,6 @@ class RendererResourceDelegate : public content::ResourceDispatcherDelegate {
   DISALLOW_COPY_AND_ASSIGN(RendererResourceDelegate);
 };
 
-static const int kWaitForWorkersStatsTimeoutMS = 20;
-
-class ResourceUsageReporterImpl : public chrome::mojom::ResourceUsageReporter {
- public:
-  explicit ResourceUsageReporterImpl(
-      base::WeakPtr<ChromeRenderThreadObserver> observer)
-      : workers_to_go_(0), observer_(observer), weak_factory_(this) {}
-  ~ResourceUsageReporterImpl() override {}
-
- private:
-  static void CollectOnWorkerThread(
-      const scoped_refptr<base::TaskRunner>& master,
-      base::WeakPtr<ResourceUsageReporterImpl> impl) {
-    size_t total_bytes = 0;
-    size_t used_bytes = 0;
-    v8::Isolate* isolate = v8::Isolate::GetCurrent();
-    if (isolate) {
-      v8::HeapStatistics heap_stats;
-      isolate->GetHeapStatistics(&heap_stats);
-      total_bytes = heap_stats.total_heap_size();
-      used_bytes = heap_stats.used_heap_size();
-    }
-    master->PostTask(FROM_HERE,
-                     base::Bind(&ResourceUsageReporterImpl::ReceiveStats, impl,
-                                total_bytes, used_bytes));
-  }
-
-  void ReceiveStats(size_t total_bytes, size_t used_bytes) {
-    usage_data_->v8_bytes_allocated += total_bytes;
-    usage_data_->v8_bytes_used += used_bytes;
-    workers_to_go_--;
-    if (!workers_to_go_)
-      SendResults();
-  }
-
-  void SendResults() {
-    if (!callback_.is_null())
-      callback_.Run(std::move(usage_data_));
-    callback_.Reset();
-    weak_factory_.InvalidateWeakPtrs();
-    workers_to_go_ = 0;
-  }
-
-  void GetUsageData(const GetUsageDataCallback& callback) override {
-    DCHECK(callback_.is_null());
-    weak_factory_.InvalidateWeakPtrs();
-    usage_data_ = chrome::mojom::ResourceUsageData::New();
-    usage_data_->reports_v8_stats = true;
-    callback_ = callback;
-
-    // Since it is not safe to call any Blink or V8 functions until Blink has
-    // been initialized (which also initializes V8), early out and send 0 back
-    // for all resources.
-    if (!observer_) {
-      SendResults();
-      return;
-    }
-
-    WebCache::ResourceTypeStats stats;
-    WebCache::GetResourceTypeStats(&stats);
-    usage_data_->web_cache_stats =
-        chrome::mojom::ResourceTypeStats::From(stats);
-
-    v8::Isolate* isolate = v8::Isolate::GetCurrent();
-    if (isolate) {
-      v8::HeapStatistics heap_stats;
-      isolate->GetHeapStatistics(&heap_stats);
-      usage_data_->v8_bytes_allocated = heap_stats.total_heap_size();
-      usage_data_->v8_bytes_used = heap_stats.used_heap_size();
-    }
-    base::Closure collect = base::Bind(
-        &ResourceUsageReporterImpl::CollectOnWorkerThread,
-        base::ThreadTaskRunnerHandle::Get(), weak_factory_.GetWeakPtr());
-    workers_to_go_ = RenderThread::Get()->PostTaskToAllWebWorkers(collect);
-    if (workers_to_go_) {
-      // The guard task to send out partial stats
-      // in case some workers are not responsive.
-      base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
-          FROM_HERE, base::Bind(&ResourceUsageReporterImpl::SendResults,
-                                weak_factory_.GetWeakPtr()),
-          base::TimeDelta::FromMilliseconds(kWaitForWorkersStatsTimeoutMS));
-    } else {
-      // No worker threads so just send out the main thread data right away.
-      SendResults();
-    }
-  }
-
-  chrome::mojom::ResourceUsageDataPtr usage_data_;
-  GetUsageDataCallback callback_;
-  int workers_to_go_;
-  base::WeakPtr<ChromeRenderThreadObserver> observer_;
-
-  base::WeakPtrFactory<ResourceUsageReporterImpl> weak_factory_;
-
-  DISALLOW_COPY_AND_ASSIGN(ResourceUsageReporterImpl);
-};
-
-void CreateResourceUsageReporter(
-    base::WeakPtr<ChromeRenderThreadObserver> observer,
-    chrome::mojom::ResourceUsageReporterRequest request) {
-  mojo::MakeStrongBinding(base::MakeUnique<ResourceUsageReporterImpl>(observer),
-                          std::move(request));
-}
-
 }  // namespace
 
 bool ChromeRenderThreadObserver::is_incognito_process_ = false;
@@ -268,9 +162,6 @@ ChromeRenderThreadObserver::ChromeRenderThreadObserver()
       native_scheme);
 
   auto registry = base::MakeUnique<service_manager::BinderRegistry>();
-  registry->AddInterface(
-      base::Bind(CreateResourceUsageReporter, weak_factory_.GetWeakPtr()),
-      base::ThreadTaskRunnerHandle::Get());
   registry->AddInterface(visited_link_slave_->GetBindCallback(),
                          base::ThreadTaskRunnerHandle::Get());
   if (content::ChildThread::Get()) {