Add IPC::Sender and GetRoutingID() to WebContents for convenience and safety.

content/browser/web_contents/web_contents_impl.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 "content/browser/web_contents/web_contents_impl.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
@@ skipping 725 matching lines @@
 
 content::RenderProcessHost* WebContentsImpl::GetRenderProcessHost() const {
   RenderViewHostImpl* host = render_manager_.current_host();
   return host ? host->GetProcess() : NULL;
 }
 
 RenderViewHost* WebContentsImpl::GetRenderViewHost() const {
   return render_manager_.current_host();
 }
 
+int WebContentsImpl::GetRoutingID() const {
+  if (!GetRenderViewHost())
+    return MSG_ROUTING_NONE;
+
+  return GetRenderViewHost()->GetRoutingID();
+}
+
 RenderWidgetHostView* WebContentsImpl::GetRenderWidgetHostView() const {
   return render_manager_.GetRenderWidgetHostView();
 }
 
 content::WebContentsView* WebContentsImpl::GetView() const {
   return view_.get();
 }
 
 content::WebUI* WebContentsImpl::CreateWebUI(const GURL& url) {
   WebUIControllerFactory* factory =
@@ skipping 678 matching lines @@
     return NULL;
 
   WebContents* new_contents = delegate_->OpenURLFromTab(this, params);
   // Notify observers.
   FOR_EACH_OBSERVER(WebContentsObserver, observers_,
                     DidOpenURL(params.url, params.referrer,
                                params.disposition, params.transition));
   return new_contents;
 }
 
+bool WebContentsImpl::Send(IPC::Message* message) {
+  if (!GetRenderViewHost()) {
+    delete message;
+    return false;
+  }
+
+  return GetRenderViewHost()->Send(message);
+}
+
 bool WebContentsImpl::NavigateToPendingEntry(
     NavigationController::ReloadType reload_type) {
   return NavigateToEntry(
       *NavigationEntryImpl::FromNavigationEntry(controller_.GetPendingEntry()),
       reload_type);
 }
 
 void WebContentsImpl::RenderViewForInterstitialPageCreated(
     content::RenderViewHost* render_view_host) {
   FOR_EACH_OBSERVER(WebContentsObserver, observers_,
@@ skipping 90 matching lines @@
   }
   RenderViewHostImpl* rvh = GetRenderViewHostImpl();
   if (!rvh) {
     NOTREACHED();
     return;
   }
   if (site_instance && rvh->GetSiteInstance() != site_instance) {
     NOTREACHED();
     return;
   }
-  rvh->Send(new ViewMsg_SetHistoryLengthAndPrune(rvh->GetRoutingID(),
-                                                 history_length,
-                                                 minimum_page_id));
+  Send(new ViewMsg_SetHistoryLengthAndPrune(GetRoutingID(),
+                                            history_length,
+                                            minimum_page_id));
 }
 
 void WebContentsImpl::FocusThroughTabTraversal(bool reverse) {
   if (ShowingInterstitialPage()) {
     render_manager_.interstitial_page()->FocusThroughTabTraversal(reverse);
     return;
   }
   GetRenderViewHostImpl()->SetInitialFocus(reverse);
 }
 
@@ skipping 64 matching lines @@
 const std::string& WebContentsImpl::GetContentsMimeType() const {
   return contents_mime_type_;
 }
 
 bool WebContentsImpl::WillNotifyDisconnection() const {
   return notify_disconnection_;
 }
 
 void WebContentsImpl::SetOverrideEncoding(const std::string& encoding) {
   SetEncoding(encoding);
-  GetRenderViewHostImpl()->Send(new ViewMsg_SetPageEncoding(
-      GetRenderViewHost()->GetRoutingID(), encoding));
+  Send(new ViewMsg_SetPageEncoding(GetRoutingID(), encoding));
 }
 
 void WebContentsImpl::ResetOverrideEncoding() {
   encoding_.clear();
-  GetRenderViewHostImpl()->Send(new ViewMsg_ResetPageEncodingToDefault(
-      GetRenderViewHost()->GetRoutingID()));
+  Send(new ViewMsg_ResetPageEncodingToDefault(GetRoutingID()));
 }
 
 content::RendererPreferences* WebContentsImpl::GetMutableRendererPrefs() {
   return &renderer_preferences_;
 }
 
 void WebContentsImpl::SetNewTabStartTime(const base::TimeTicks& time) {
   new_tab_start_time_ = time;
 }
 
@@ skipping 161 matching lines @@
   return GetRenderViewHost() ?
       GetRenderViewHostImpl()->GotResponseToLockMouseRequest(allowed) : false;
 }
 
 bool WebContentsImpl::HasOpener() const {
   return opener_ != NULL;
 }
 
 void WebContentsImpl::DidChooseColorInColorChooser(int color_chooser_id,
                                                    SkColor color) {
-  GetRenderViewHost()->Send(new ViewMsg_DidChooseColorResponse(
-      GetRenderViewHost()->GetRoutingID(), color_chooser_id, color));
+  Send(new ViewMsg_DidChooseColorResponse(
+      GetRoutingID(), color_chooser_id, color));
 }
 
 void WebContentsImpl::DidEndColorChooser(int color_chooser_id) {
-  GetRenderViewHost()->Send(new ViewMsg_DidEndColorChooser(
-      GetRenderViewHost()->GetRoutingID(), color_chooser_id));
+  Send(new ViewMsg_DidEndColorChooser(GetRoutingID(), color_chooser_id));
   if (delegate_)
     delegate_->DidEndColorChooser();
   color_chooser_ = NULL;
 }
 
 bool WebContentsImpl::FocusLocationBarByDefault() {
   content::WebUI* web_ui = GetWebUIForCurrentState();
   if (web_ui)
     return web_ui->ShouldFocusLocationBarByDefault();
   NavigationEntry* entry = controller_.GetActiveEntry();
@@ skipping 590 matching lines @@
   if (!entry)
     return;
 
   // When we're creating views, we're still doing initial setup, so we always
   // use the pending Web UI rather than any possibly existing committed one.
   if (render_manager_.pending_web_ui())
     render_manager_.pending_web_ui()->RenderViewCreated(render_view_host);
 
   if (entry->IsViewSourceMode()) {
     // Put the renderer in view source mode.
-    static_cast<RenderViewHostImpl*>(render_view_host)->Send(
-        new ViewMsg_EnableViewSourceMode(render_view_host->GetRoutingID()));
+    Send(new ViewMsg_EnableViewSourceMode(GetRoutingID()));

[jam, 2012/08/15 16:22:02]

I think you need to keep this as is.

render_view_host might not be equal to GetRenderViewHost() in case of pending
RVHs

[Jói, 2012/08/15 19:13:24]

Phew, thanks for catching that!

   }
 
   GetView()->RenderViewCreated(render_view_host);
 
   FOR_EACH_OBSERVER(
       WebContentsObserver, observers_, RenderViewCreated(render_view_host));
 }
 
 void WebContentsImpl::RenderViewReady(RenderViewHost* rvh) {
   if (rvh != GetRenderViewHost()) {
@@ skipping 372 matching lines @@
           source_contents->CreateOpenerRenderViews(GetSiteInstance());
     } else {
       // We couldn't find it, so don't pass a source frame.
       new_params.source_routing_id = MSG_ROUTING_NONE;
     }
   }
 
   // In most cases, we receive this from a swapped out RenderViewHost.
   // It is possible to receive it from one that has just been swapped in,
   // in which case we might as well deliver the message anyway.
-  GetRenderViewHost()->Send(new ViewMsg_PostMessageEvent(
-      GetRenderViewHost()->GetRoutingID(), new_params));
+  Send(new ViewMsg_PostMessageEvent(GetRoutingID(), new_params));
 }
 
 void WebContentsImpl::RunJavaScriptMessage(
     RenderViewHost* rvh,
     const string16& message,
     const string16& default_prompt,
     const GURL& frame_url,
     content::JavaScriptMessageType javascript_message_type,
     IPC::Message* reply_msg,
     bool* did_suppress_message) {
@@ skipping 331 matching lines @@
       old_browser_plugin_host()->embedder_render_process_host();
   *embedder_container_id = old_browser_plugin_host()->instance_id();
   int embedder_process_id =
       embedder_render_process_host ? embedder_render_process_host->GetID() : -1;
   if (embedder_process_id != -1) {
     *embedder_channel_name =
         StringPrintf("%d.r%d", render_view_host->GetProcess()->GetID(),
                      embedder_process_id);
   }
 }