Browser Plugin: Simplified BrowserPluginManager

content/browser/browser_plugin/browser_plugin_guest.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/browser_plugin/browser_plugin_guest.h"
 
 #include <algorithm>
 
 #include "base/string_util.h"
 #include "content/browser/browser_plugin/browser_plugin_embedder.h"
@@ skipping 94 matching lines @@
       break;
     }
     default:
       NOTREACHED() << "Unexpected notification sent.";
       break;
   }
 }
 
 bool BrowserPluginGuest::ViewTakeFocus(bool reverse) {
   SendMessageToEmbedder(
-      new BrowserPluginMsg_AdvanceFocus(instance_id(), reverse));
+      new BrowserPluginMsg_AdvanceFocus(embedder_routing_id(),
+                                        instance_id(),
+                                        reverse));
   return true;
 }
 
 void BrowserPluginGuest::Go(int relative_index) {
   web_contents()->GetController().GoToOffset(relative_index);
 }
 
 bool BrowserPluginGuest::CanDownload(RenderViewHost* render_view_host,
                                     int request_id,
                                     const std::string& request_method) {
@@ skipping 25 matching lines @@
 }
 
 bool BrowserPluginGuest::ShouldFocusPageAfterCrash() {
   // Rather than managing focus in WebContentsImpl::RenderViewReady, we will
   // manage the focus ourselves.
   return false;
 }
 
 void BrowserPluginGuest::SetIsAcceptingTouchEvents(bool accept) {
   SendMessageToEmbedder(
-      new BrowserPluginMsg_ShouldAcceptTouchEvents(instance_id(), accept));
+      new BrowserPluginMsg_ShouldAcceptTouchEvents(embedder_routing_id(),
+                                                   instance_id(),
+                                                   accept));
 }
 
 void BrowserPluginGuest::SetVisibility(bool embedder_visible, bool visible) {
   visible_ = visible;
   if (embedder_visible && visible)
     web_contents()->WasShown();
   else
     web_contents()->WasHidden();
 }
 
@@ skipping 122 matching lines @@
   // between the embedder and browser processes.
   DCHECK(*static_cast<unsigned int*>(damage_buffer->memory()) == 0xdeadbeef);
   damage_buffer_.reset(damage_buffer);
 #if defined(OS_WIN)
   damage_buffer_size_ = damage_buffer_size;
 #endif
   damage_view_size_ = damage_view_size;
   damage_buffer_scale_factor_ = scale_factor;
 }
 
+int BrowserPluginGuest::embedder_routing_id() const {
+  return embedder_web_contents_->GetRoutingID();
+}
+
 bool BrowserPluginGuest::InAutoSizeBounds(const gfx::Size& size) const {
   return size.width() <= max_auto_size_.width() &&
       size.height() <= max_auto_size_.height();
 }
 
 void BrowserPluginGuest::UpdateRect(
     RenderViewHost* render_view_host,
     const ViewHostMsg_UpdateRect_Params& params) {
   RenderWidgetHostImpl* render_widget_host =
       RenderWidgetHostImpl::From(render_view_host);
@@ skipping 43 matching lines @@
       params.flags);
 
   // We need to send the ACK to the same render_view_host that issued
   // the UpdateRect. We keep track of this correspondence via a message_id.
   int message_id = pending_update_counter_++;
   pending_updates_.AddWithID(render_view_host, message_id);
 
   gfx::Size param_size = gfx::Size(params.view_size.width(),
                                    params.view_size.height());
 
-  SendMessageToEmbedder(new BrowserPluginMsg_UpdateRect(instance_id(),
+  SendMessageToEmbedder(new BrowserPluginMsg_UpdateRect(embedder_routing_id(),
+                                                        instance_id(),
                                                         message_id,
                                                         relay_params));
 }
 
 void BrowserPluginGuest::UpdateRectACK(int message_id, const gfx::Size& size) {
   RenderViewHost* render_view_host = pending_updates_.Lookup(message_id);
   // If the guest has crashed since it sent the initial ViewHostMsg_UpdateRect
   // then the pending_updates_ map will have been cleared.
   if (!render_view_host)
     return;
@@ skipping 84 matching lines @@
 void BrowserPluginGuest::ShowWidget(RenderViewHost* render_view_host,
                                     int route_id,
                                     const gfx::Rect& initial_pos) {
   gfx::Rect screen_pos(initial_pos);
   screen_pos.Offset(guest_rect_.OffsetFromOrigin());
   static_cast<WebContentsImpl*>(web_contents())->ShowCreatedWidget(route_id,
                                                                    screen_pos);
 }
 
 void BrowserPluginGuest::SetCursor(const WebCursor& cursor) {
-  SendMessageToEmbedder(new BrowserPluginMsg_SetCursor(instance_id(), cursor));
+  SendMessageToEmbedder(new BrowserPluginMsg_SetCursor(embedder_routing_id(),
+                                                       instance_id(),
+                                                       cursor));
 }
 
 void BrowserPluginGuest::DidStartProvisionalLoadForFrame(
     int64 frame_id,
     int64 parent_frame_id,
     bool is_main_frame,
     const GURL& validated_url,
     bool is_error_page,
     RenderViewHost* render_view_host) {
   // Inform the embedder of the loadStart.
   SendMessageToEmbedder(
-      new BrowserPluginMsg_LoadStart(instance_id(),
+      new BrowserPluginMsg_LoadStart(embedder_routing_id(),
+                                     instance_id(),
                                      validated_url,
                                      is_main_frame));
 }
 
 void BrowserPluginGuest::DidFailProvisionalLoad(
     int64 frame_id,
     bool is_main_frame,
     const GURL& validated_url,
     int error_code,
     const string16& error_description,
     RenderViewHost* render_view_host) {
   // Translate the |error_code| into an error string.
   std::string error_type;
   RemoveChars(net::ErrorToString(error_code), "net::", &error_type);
   // Inform the embedder of the loadAbort.
   SendMessageToEmbedder(
-      new BrowserPluginMsg_LoadAbort(instance_id(),
+      new BrowserPluginMsg_LoadAbort(embedder_routing_id(),
+                                     instance_id(),
                                      validated_url,
                                      is_main_frame,
                                      error_type));
 }
 
 void BrowserPluginGuest::LoadRedirect(
     const GURL& old_url,
     const GURL& new_url,
     bool is_top_level) {
   SendMessageToEmbedder(
-      new BrowserPluginMsg_LoadRedirect(
-          instance_id(), old_url, new_url, is_top_level));
+      new BrowserPluginMsg_LoadRedirect(embedder_routing_id(),
+                                        instance_id(),
+                                        old_url,
+                                        new_url,
+                                        is_top_level));
 }
 
 void BrowserPluginGuest::DidCommitProvisionalLoadForFrame(
     int64 frame_id,
     bool is_main_frame,
     const GURL& url,
     PageTransition transition_type,
     RenderViewHost* render_view_host) {
   // Inform its embedder of the updated URL.
   BrowserPluginMsg_LoadCommit_Params params;
   params.url = url;
   params.is_top_level = is_main_frame;
   params.process_id = render_view_host->GetProcess()->GetID();
   params.current_entry_index =
       web_contents()->GetController().GetCurrentEntryIndex();
   params.entry_count =
       web_contents()->GetController().GetEntryCount();
   SendMessageToEmbedder(
-      new BrowserPluginMsg_LoadCommit(instance_id(), params));
+      new BrowserPluginMsg_LoadCommit(embedder_routing_id(),
+                                      instance_id(),
+                                      params));
   RecordAction(UserMetricsAction("BrowserPlugin.Guest.DidNavigate"));
 }
 
 void BrowserPluginGuest::DidStopLoading(RenderViewHost* render_view_host) {
-  SendMessageToEmbedder(new BrowserPluginMsg_LoadStop(instance_id()));
+  SendMessageToEmbedder(new BrowserPluginMsg_LoadStop(embedder_routing_id(),
+                                                      instance_id()));
 }
 
 void BrowserPluginGuest::RenderViewReady() {
   // TODO(fsamuel): Investigate whether it's possible to update state earlier
   // here (see http://www.crbug.com/158151).
   RenderViewHost* render_view_host = web_contents()->GetRenderViewHost();
   render_view_host->Send(
       new ViewMsg_SetFocus(render_view_host->GetRoutingID(), focused_));
   bool embedder_visible =
       embedder_web_contents_->GetBrowserPluginEmbedder()->visible();
   SetVisibility(embedder_visible, visible());
   if (auto_size_) {
     web_contents()->GetRenderViewHost()->EnableAutoResize(
         min_auto_size_, max_auto_size_);
   } else {
     web_contents()->GetRenderViewHost()->DisableAutoResize(damage_view_size_);
   }
 }
 
 void BrowserPluginGuest::RenderViewGone(base::TerminationStatus status) {
   if (pending_input_event_reply_.get()) {
     IPC::Message* reply_message = pending_input_event_reply_.release();
     BrowserPluginHostMsg_HandleInputEvent::WriteReplyParams(reply_message,
                                                             false);
     SendMessageToEmbedder(reply_message);
   }
   int process_id = web_contents()->GetRenderProcessHost()->GetID();
-  SendMessageToEmbedder(new BrowserPluginMsg_GuestGone(instance_id(),
+  SendMessageToEmbedder(new BrowserPluginMsg_GuestGone(embedder_routing_id(),
+                                                       instance_id(),
                                                        process_id,
                                                        status));
   IDMap<RenderViewHost>::const_iterator iter(&pending_updates_);
   while (!iter.IsAtEnd()) {
     pending_updates_.Remove(iter.GetCurrentKey());
     iter.Advance();
   }
 
   switch (status) {
     case base::TERMINATION_STATUS_PROCESS_WAS_KILLED:
       RecordAction(UserMetricsAction("BrowserPlugin.Guest.Killed"));
       break;
     case base::TERMINATION_STATUS_PROCESS_CRASHED:
       RecordAction(UserMetricsAction("BrowserPlugin.Guest.Crashed"));
       break;
     case base::TERMINATION_STATUS_ABNORMAL_TERMINATION:
       RecordAction(UserMetricsAction("BrowserPlugin.Guest.AbnormalDeath"));
       break;
     default:
       break;
   }
 }
 
 void BrowserPluginGuest::SendMessageToEmbedder(IPC::Message* msg) {
   embedder_web_contents_->GetRenderProcessHost()->Send(msg);
 }
 
 }  // namespace content