Extract minimal RenderViewHost interface for embedders, leaving

chrome/browser/prerender/prerender_contents.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/browser/prerender/prerender_contents.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/process_util.h"
@@ skipping 234 matching lines @@
   DCHECK(prerender_contents_.get() == NULL);
 
   prerendering_has_started_ = true;
   WebContents* new_contents = WebContents::Create(
       profile_, NULL, MSG_ROUTING_NONE, NULL, session_storage_namespace);
   prerender_contents_.reset(new TabContentsWrapper(new_contents));
   content::WebContentsObserver::Observe(new_contents);
 
   gfx::Rect tab_bounds = prerender_manager_->config().default_tab_bounds;
   if (source_render_view_host) {
-    DCHECK(source_render_view_host->view() != NULL);
+    DCHECK(source_render_view_host->GetView() != NULL);
     WebContents* source_wc =
-        source_render_view_host->delegate()->GetAsWebContents();
+        source_render_view_host->GetDelegate()->GetAsWebContents();
     if (source_wc) {
       // Set the size of the new TC to that of the old TC.
       source_wc->GetView()->GetContainerBounds(&tab_bounds);
     }
   } else {
     // Try to get the active tab of the active browser and use that for tab
     // bounds. If the browser has never been active, we will fail to get a size
     // but we shouldn't be prerendering in that case anyway.
     Browser* active_browser = BrowserList::GetLastActiveWithProfile(profile_);
     if (active_browser) {
       WebContents* active_web_contents = active_browser->GetWebContentsAt(
           active_browser->active_index());
       if (active_web_contents)
         active_web_contents->GetView()->GetContainerBounds(&tab_bounds);
     }
   }
 
   tab_contents_delegate_.reset(new TabContentsDelegateImpl(this));
   new_contents->SetDelegate(tab_contents_delegate_.get());
 
   // Set the size of the prerender TabContents.
   prerender_contents_->web_contents()->GetView()->SizeContents(
       tab_bounds.size());
 
   // Register as an observer of the RenderViewHost so we get messages.
   render_view_host_observer_.reset(
       new PrerenderRenderViewHostObserver(this, render_view_host_mutable()));
 
-  child_id_ = render_view_host()->process()->GetID();
-  route_id_ = render_view_host()->routing_id();
+  child_id_ = render_view_host()->GetProcess()->GetID();
+  route_id_ = render_view_host()->GetRoutingID();
 
   // Register this with the ResourceDispatcherHost as a prerender
   // RenderViewHost. This must be done before the Navigate message to catch all
   // resource requests, but as it is on the same thread as the Navigate message
   // (IO) there is no race condition.
   prerender_tracker_->OnPrerenderingStarted(
       child_id_,
       route_id_,
       prerender_manager_);
 
@@ skipping 112 matching lines @@
         content::Details<RenderViewHost> new_render_view_host(details);
         OnRenderViewHostCreated(new_render_view_host.ptr());
 
         // When a new RenderView is created for a prerendering TabContents,
         // tell the new RenderView it's being used for prerendering before any
         // navigations occur.  Note that this is always triggered before the
         // first navigation, so there's no need to send the message just after
         // the TabContents is created.
         new_render_view_host->Send(
             new ChromeViewMsg_SetIsPrerendering(
-                new_render_view_host->routing_id(),
+                new_render_view_host->GetRoutingID(),
                 true));
 
         // Make sure the size of the RenderViewHost has been passed to the new
         // RenderView.  Otherwise, the size may not be sent until the
         // RenderViewReady event makes it from the render process to the UI
         // thread of the browser process.  When the RenderView receives its
         // size, is also sets itself to be visible, which would then break the
         // visibility API.
         new_render_view_host->WasResized();
         prerender_contents_->web_contents()->HideContents();
@@ skipping 147 matching lines @@
   // We may destroy the PrerenderContents before we have initialized the
   // RenderViewHost. Otherwise set the Observer's PrerenderContents to NULL to
   // avoid any more messages being sent.
   if (render_view_host_observer_.get())
     render_view_host_observer_->set_prerender_contents(NULL);
 }
 
 base::ProcessMetrics* PrerenderContents::MaybeGetProcessMetrics() {
   if (process_metrics_.get() == NULL) {
     // If a PrenderContents hasn't started prerending, don't be fully formed.
-    if (!render_view_host() || !render_view_host()->process())
+    if (!render_view_host() || !render_view_host()->GetProcess())
       return NULL;
-    base::ProcessHandle handle = render_view_host()->process()->GetHandle();
+    base::ProcessHandle handle = render_view_host()->GetProcess()->GetHandle();
     if (handle == base::kNullProcessHandle)
       return NULL;
 #if !defined(OS_MACOSX)
     process_metrics_.reset(base::ProcessMetrics::CreateProcessMetrics(handle));
 #else
     process_metrics_.reset(base::ProcessMetrics::CreateProcessMetrics(
         handle,
         content::BrowserChildProcessHost::GetPortProvider()));
 #endif
   }
@@ skipping 55 matching lines @@
 bool PrerenderContents::IsCrossSiteNavigationPending() const {
   if (!prerender_contents_.get() || !prerender_contents_->web_contents())
     return false;
   const WebContents* web_contents = prerender_contents_->web_contents();
   return (web_contents->GetSiteInstance() !=
           web_contents->GetPendingSiteInstance());
 }
 
 
 }  // namespace prerender