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

chrome/browser/visitedlink/visitedlink_unittest.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 <cstdio>
 #include <string>
 #include <vector>
 
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
 #include "base/shared_memory.h"
 #include "base/string_util.h"
 #include "chrome/browser/visitedlink/visitedlink_event_listener.h"
 #include "chrome/browser/visitedlink/visitedlink_master.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/renderer/visitedlink_slave.h"
 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
 #include "chrome/test/base/testing_profile.h"
-#include "content/browser/renderer_host/browser_render_process_host.h"
+#include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/test/test_browser_thread.h"
 #include "googleurl/src/gurl.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::BrowserThread;
 
 namespace {
 
@@ skipping 456 matching lines @@
   int reset_event_count() const { return reset_event_count_; }
 
  private:
   int add_count_;
   int add_event_count_;
   int reset_event_count_;
   scoped_ptr<VisitedLinkEventListener> event_listener_;
   scoped_ptr<VisitedLinkMaster> visited_link_master_;
 };
 
-// Stub out as little as possible, borrowing from BrowserRenderProcessHost.
-class VisitRelayingRenderProcessHost : public BrowserRenderProcessHost {
+// Stub out as little as possible, borrowing from RenderProcessHost.
+class VisitRelayingRenderProcessHost : public RenderProcessHostImpl {
  public:
   explicit VisitRelayingRenderProcessHost(
       content::BrowserContext* browser_context)
-          : BrowserRenderProcessHost(browser_context) {
+          : RenderProcessHostImpl(browser_context) {
     content::NotificationService::current()->Notify(
         content::NOTIFICATION_RENDERER_PROCESS_CREATED,
         content::Source<RenderProcessHost>(this),
         content::NotificationService::NoDetails());
   }
   virtual ~VisitRelayingRenderProcessHost() {
     content::NotificationService::current()->Notify(
         content::NOTIFICATION_RENDERER_PROCESS_TERMINATED,
-        content::Source<RenderProcessHost>(this),
+        content::Source<content::RenderProcessHost>(this),
         content::NotificationService::NoDetails());
   }
 
   virtual bool Init(bool is_accessibility_enabled) {
     return true;
   }
 
   virtual void CancelResourceRequests(int render_widget_id) {
   }
 
   virtual void CrossSiteSwapOutACK(const ViewMsg_SwapOut_Params& params) {
   }
 
   virtual bool WaitForPaintMsg(int render_widget_id,
                                const base::TimeDelta& max_delay,
                                IPC::Message* msg) {
     return false;
   }
 
   virtual bool Send(IPC::Message* msg) {
     VisitCountingProfile* counting_profile =
         static_cast<VisitCountingProfile*>(
-            Profile::FromBrowserContext(browser_context()));
+            Profile::FromBrowserContext(GetBrowserContext()));
 
     if (msg->type() == ChromeViewMsg_VisitedLink_Add::ID) {
       void* iter = NULL;
       std::vector<uint64> fingerprints;
       CHECK(IPC::ReadParam(msg, &iter, &fingerprints));
       counting_profile->CountAddEvent(fingerprints.size());
     } else if (msg->type() == ChromeViewMsg_VisitedLink_Reset::ID) {
       counting_profile->CountResetEvent();
     }
 
     delete msg;
     return true;
   }
 
   virtual void SetBackgrounded(bool backgrounded) {
     backgrounded_ = backgrounded;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(VisitRelayingRenderProcessHost);
 };
 
 class VisitedLinkRenderProcessHostFactory
-    : public RenderProcessHostFactory {
+    : public content::RenderProcessHostFactory {
  public:
   VisitedLinkRenderProcessHostFactory()
-      : RenderProcessHostFactory() {}
-  virtual RenderProcessHost* CreateRenderProcessHost(
+      : content::RenderProcessHostFactory() {}
+  virtual content::RenderProcessHost* CreateRenderProcessHost(
       content::BrowserContext* browser_context) const OVERRIDE {
     return new VisitRelayingRenderProcessHost(browser_context);
   }
 
  private:
 
   DISALLOW_COPY_AND_ASSIGN(VisitedLinkRenderProcessHostFactory);
 };
 
 class VisitedLinkEventsTest : public ChromeRenderViewHostTestHarness {
@@ skipping 146 matching lines @@
   EXPECT_EQ(1, profile()->add_event_count());
   EXPECT_EQ(0, profile()->reset_event_count());
 
   // Activate the tab.
   rvh()->WasRestored();
 
   // We should have only one more reset event.
   EXPECT_EQ(1, profile()->add_event_count());
   EXPECT_EQ(1, profile()->reset_event_count());
 }