Add chrome namespace to chrome/common/resource_usage_reporter.mojom

chrome/renderer/chrome_render_thread_observer.cc

 // Copyright (c) 2012 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 "chrome/renderer/chrome_render_thread_observer.h"
 
 #include <stddef.h>
 
 #include <limits>
 #include <memory>
@@ skipping 109 matching lines @@
         static_cast<uint64_t>(stats.deadSize)));
   }
 
   base::WeakPtrFactory<RendererResourceDelegate> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RendererResourceDelegate);
 };
 
 static const int kWaitForWorkersStatsTimeoutMS = 20;
 
-class ResourceUsageReporterImpl : public mojom::ResourceUsageReporter {
+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) {
@@ skipping 23 matching lines @@
     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_ = mojom::ResourceUsageData::New();
+    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 = mojom::ResourceTypeStats::From(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();
     }
   }
 
-  mojom::ResourceUsageDataPtr usage_data_;
+  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,
-    mojo::InterfaceRequest<mojom::ResourceUsageReporter> request) {
+    mojo::InterfaceRequest<chrome::mojom::ResourceUsageReporter> request) {
   mojo::MakeStrongBinding(base::MakeUnique<ResourceUsageReporterImpl>(observer),
                           std::move(request));
 }
 
 }  // namespace
 
 bool ChromeRenderThreadObserver::is_incognito_process_ = false;
 
 ChromeRenderThreadObserver::ChromeRenderThreadObserver()
     : field_trial_syncer_(this),
@@ skipping 73 matching lines @@
 void ChromeRenderThreadObserver::OnSetFieldTrialGroup(
     const std::string& trial_name,
     const std::string& group_name) {
   field_trial_syncer_.OnSetFieldTrialGroup(trial_name, group_name);
 }
 
 const RendererContentSettingRules*
 ChromeRenderThreadObserver::content_setting_rules() const {
   return &content_setting_rules_;
 }