Define the public version of the browser side RenderProcessHost interface. This interface is not ...

chrome/browser/metrics/tracking_synchronizer.cc

 // Copyright (c) 2011 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/browser/metrics/tracking_synchronizer.h"
 
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/threading/thread.h"
 #include "base/tracked_objects.h"
 #include "chrome/browser/ui/webui/tracing_ui.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/render_messages.h"
-#include "content/browser/renderer_host/render_process_host.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/render_process_host.h"
 
 using base::TimeTicks;
 using content::BrowserThread;
 
 namespace chrome_browser_metrics {
 
 // Negative numbers are never used as sequence numbers.  We explicitly pick a
 // negative number that is "so negative" that even when we add one (as is done
 // when we generated the next sequence number) that it will still be negative.
 // We have code that handles wrapping around on an overflow into negative
@@ skipping 48 matching lines @@
           sequence_number),
       60000);
 }
 
 // static
 void TrackingSynchronizer::SetTrackingStatus(bool enable) {
   // To iterate over all processes, or to send messages to the hosts, we need
   // to be on the UI thread.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  for (RenderProcessHost::iterator it(RenderProcessHost::AllHostsIterator());
+  for (content::RenderProcessHost::iterator it(
+          content::RenderProcessHost::AllHostsIterator());
        !it.IsAtEnd(); it.Advance()) {
-    RenderProcessHost* render_process_host = it.GetCurrentValue();
+    content::RenderProcessHost* render_process_host = it.GetCurrentValue();
     DCHECK(render_process_host);
     // Ignore processes that don't have a connection, such as crashed tabs.
     if (!render_process_host->HasConnection())
       continue;
 
     render_process_host->Send(new ChromeViewMsg_SetTrackingStatus(enable));
   }
 }
 
 // static
 void TrackingSynchronizer::IsTrackingEnabled(int process_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   // To find the process, or to send messages to the hosts, we need to be on the
   // UI thread.
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(
           &TrackingSynchronizer::SetTrackingStatusInProcess, process_id));
 }
 
 // static
 void TrackingSynchronizer::SetTrackingStatusInProcess(int process_id) {
   // To find the process, or to send messages to the hosts, we need to be on the
   // UI thread.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   bool enable = tracked_objects::ThreadData::tracking_status();
 
-  RenderProcessHost* process = RenderProcessHost::FromID(process_id);
+  content::RenderProcessHost* process =
+      content::RenderProcessHost::FromID(process_id);
   // Ignore processes that don't have a connection, such as crashed tabs.
   if (!process || !process->HasConnection())
     return;
   process->Send(new ChromeViewMsg_SetTrackingStatus(enable));
 }
 
 // static
 void TrackingSynchronizer::DeserializeTrackingList(
     int sequence_number,
     const std::string& tracking_data,
@@ skipping 37 matching lines @@
 
   int sequence_number = GetNextAvailableSequenceNumber();
 
   // Initialize processes_pending with one because we are going to send
   // browser's ThreadData.
   RequestContext* request = new RequestContext(
       callback_object, sequence_number, 1, TimeTicks::Now());
   outstanding_requests_[sequence_number] = request;
 
   DCHECK_GT(request->processes_pending_, 0);
-  for (RenderProcessHost::iterator it(RenderProcessHost::AllHostsIterator());
+  for (content::RenderProcessHost::iterator it(
+          content::RenderProcessHost::AllHostsIterator());
        !it.IsAtEnd(); it.Advance()) {
-    RenderProcessHost* render_process_host = it.GetCurrentValue();
+    content::RenderProcessHost* render_process_host = it.GetCurrentValue();
     DCHECK(render_process_host);
     // Ignore processes that don't have a connection, such as crashed tabs.
     if (!render_process_host->HasConnection())
       continue;
 
     ++request->processes_pending_;
     if (!render_process_host->Send(
         new ChromeViewMsg_GetRendererTrackedData(sequence_number))) {
       DecrementPendingProcesses(sequence_number);
     }
@@ skipping 73 matching lines @@
   // Watch out for wrapping to a negative number.
   if (last_used_sequence_number_ < 0)
     last_used_sequence_number_ = 1;
   return last_used_sequence_number_;
 }
 
 // static
 TrackingSynchronizer* TrackingSynchronizer::tracking_synchronizer_ = NULL;
 
 }  // namespace chrome_browser_metrics