Browser Plugin: Expose frame name changes to the content API

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/message_loop.h"
 #include "base/string_util.h"
@@ skipping 189 matching lines @@
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void BrowserPluginGuest::Initialize(
     WebContentsImpl* embedder_web_contents,
     const BrowserPluginHostMsg_CreateGuest_Params& params) {
   focused_ = params.focused;
   guest_visible_ = params.visible;
   if (!params.name.empty())
-    name_ = params.name;
+    GetWebContents()->SetWindowName(params.name);

[Charlie Reis, 2013/04/18 21:26:51]

Why is this needed?  Won't the RenderView tell the WebContents?

   auto_size_enabled_ = params.auto_size_params.enable;
   max_auto_size_ = params.auto_size_params.max_size;
   min_auto_size_ = params.auto_size_params.min_size;
 
   // Once a BrowserPluginGuest has an embedder WebContents, it's considered to
   // be attached.
   embedder_web_contents_ = embedder_web_contents;
 
   // |render_view_host| manages the ownership of this BrowserPluginGuestHelper.
   new BrowserPluginGuestHelper(this, GetWebContents()->GetRenderViewHost());
@@ skipping 145 matching lines @@
 
 void BrowserPluginGuest::WebContentsCreated(WebContents* source_contents,
                                             int64 source_frame_id,
                                             const string16& frame_name,
                                             const GURL& target_url,
                                             WebContents* new_contents) {
   WebContentsImpl* new_contents_impl =
       static_cast<WebContentsImpl*>(new_contents);
   BrowserPluginGuest* guest = new_contents_impl->GetBrowserPluginGuest();
   guest->opener_ = this;
-  guest->name_ = UTF16ToUTF8(frame_name);
+  new_contents_impl->SetWindowName(UTF16ToUTF8(frame_name));

[Charlie Reis, 2013/04/18 21:26:51]

Again, won't RenderView tell us?

   // Take ownership of the new guest until it is attached to the embedder's DOM
   // tree to avoid leaking a guest if this guest is destroyed before attaching
   // the new guest.
   pending_new_windows_.insert(make_pair(guest, target_url.spec()));
 }
 
 void BrowserPluginGuest::RendererUnresponsive(WebContents* source) {
   int process_id =
       GetWebContents()->GetRenderProcessHost()->GetID();
   SendMessageToEmbedder(
@@ skipping 222 matching lines @@
   // Initiating a drag from inside a guest is currently not supported. So inject
   // some JS to disable it. http://crbug.com/161112
   const char script[] = "window.addEventListener('dragstart', function() { "
                         "  window.event.preventDefault(); "
                         "});";
   render_view_host->ExecuteJavascriptInWebFrame(string16(),
                                                 ASCIIToUTF16(script));
   SendMessageToEmbedder(new BrowserPluginMsg_LoadStop(instance_id()));
 }
 
+void BrowserPluginGuest::DidUpdateFrameName(int frame_id,
+                                            bool is_top_level,
+                                            const std::string& name,
+                                            RenderViewHost* render_view_host) {
+  if (!is_top_level)
+    return;
+
+  SendMessageToEmbedder(new BrowserPluginMsg_UpdatedName(instance_id_, name));
+}
+
 void BrowserPluginGuest::RenderViewReady() {
   // TODO(fsamuel): Investigate whether it's possible to update state earlier
   // here (see http://crbug.com/158151).
   Send(new ViewMsg_SetFocus(routing_id(), focused_));
   UpdateVisibility();
   RenderViewHost* rvh = GetWebContents()->GetRenderViewHost();
   if (auto_size_enabled_)
     rvh->EnableAutoResize(min_auto_size_, max_auto_size_);
   else
     rvh->DisableAutoResize(damage_view_size_);
 
-  Send(new ViewMsg_SetName(routing_id(), name_));
-
   RenderWidgetHostImpl::From(rvh)->
       set_hung_renderer_delay_ms(guest_hang_timeout_);
 }
 
 void BrowserPluginGuest::RenderViewGone(base::TerminationStatus status) {
   int process_id = GetWebContents()->GetRenderProcessHost()->GetID();
   SendMessageToEmbedder(
       new BrowserPluginMsg_GuestGone(instance_id(), process_id, status));
   switch (status) {
     case base::TERMINATION_STATUS_PROCESS_WAS_KILLED:
@@ skipping 64 matching lines @@
  #if defined(OS_MACOSX)
     // MacOSX creates and populates platform-specific select drop-down menus
     // whereas other platforms merely create a popup window that the guest
     // renderer process paints inside.
     IPC_MESSAGE_HANDLER(ViewHostMsg_ShowPopup, OnShowPopup)
  #endif
     IPC_MESSAGE_HANDLER(ViewHostMsg_ShowWidget, OnShowWidget)
     IPC_MESSAGE_HANDLER(ViewHostMsg_TakeFocus, OnTakeFocus)
     IPC_MESSAGE_HANDLER(ViewHostMsg_UnlockMouse, OnUnlockMouse)
     IPC_MESSAGE_HANDLER(DragHostMsg_UpdateDragCursor, OnUpdateDragCursor)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_UpdateFrameName, OnUpdateFrameName)
     IPC_MESSAGE_HANDLER(ViewHostMsg_UpdateRect, OnUpdateRect)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void BrowserPluginGuest::Attach(
     WebContentsImpl* embedder_web_contents,
     BrowserPluginHostMsg_CreateGuest_Params params) {
   const std::string target_url = opener()->pending_new_windows_[this];
   if (!GetWebContents()->opener()) {
     // For guests that have a suppressed opener, we navigate now.
     // Navigation triggers the creation of a RenderWidgetHostViewGuest so
     // we don't need to create one manually.
     params.src = target_url;
   } else {
     // Ensure that the newly attached guest gets a RenderWidgetHostViewGuest.
     WebContentsViewGuest* new_view =
         static_cast<WebContentsViewGuest*>(GetWebContents()->GetView());
     new_view->CreateViewForWidget(web_contents()->GetRenderViewHost());
   }
   // Once a new guest is attached to the DOM of the embedder page, then the
   // lifetime of the new guest is no longer managed by the opener guest.
   opener()->pending_new_windows_.erase(this);
 
   // The guest's frame name takes precedence over the BrowserPlugin's name.
   // The guest's frame name is assigned in
   // BrowserPluginGuest::WebContentsCreated.
-  if (!name_.empty())
+  if (!GetWebContents()->GetWindowName().empty())
     params.name.clear();
 
   Initialize(embedder_web_contents, params);
 
   // We initialize the RenderViewHost after a BrowserPlugin has been attached
   // to it and is ready to receive pixels. Until a RenderViewHost is
   // initialized, it will not allow any resize requests.
   if (!GetWebContents()->GetRenderViewHost()->IsRenderViewLive()) {
     static_cast<RenderViewHostImpl*>(
         GetWebContents()->GetRenderViewHost())->Init();
   }
 
   // Inform the embedder of the guest's information.
   // We pull the partition information from the site's URL, which is of the form
   // guest://site/{persist}?{partition_name}.
   const GURL& site_url = GetWebContents()->GetSiteInstance()->GetSiteURL();
   BrowserPluginMsg_Attach_ACK_Params ack_params;
   ack_params.storage_partition_id = site_url.query();
   ack_params.persist_storage =
       site_url.path().find("persist") != std::string::npos;
-  ack_params.name = name_;
+  ack_params.name = GetWebContents()->GetWindowName();
   SendMessageToEmbedder(
       new BrowserPluginMsg_Attach_ACK(instance_id_, ack_params));
 }
 
 void BrowserPluginGuest::OnCompositorFrameACK(
     int instance_id,
     int route_id,
     int renderer_host_id,
     const cc::CompositorFrameAck& ack) {
   RenderWidgetHostImpl::SendSwapCompositorFrameAck(route_id,
@@ skipping 171 matching lines @@
 }
 
 void BrowserPluginGuest::OnSetFocus(int instance_id, bool focused) {
   if (focused_ == focused)
       return;
   focused_ = focused;
   Send(new ViewMsg_SetFocus(routing_id(), focused));
 }
 
 void BrowserPluginGuest::OnSetName(int instance_id, const std::string& name) {
-  if (name == name_)
-    return;
-  name_ = name;
-  Send(new ViewMsg_SetName(routing_id(), name));
+  GetWebContents()->SetWindowName(name);

[Charlie Reis, 2013/04/18 21:26:51]

Again, why is this needed?  If we change the name in the RenderView, it will let
the WebContents know on its own.

 }
 
 void BrowserPluginGuest::OnSetSize(
     int instance_id,
     const BrowserPluginHostMsg_AutoSize_Params& auto_size_params,
     const BrowserPluginHostMsg_ResizeGuest_Params& resize_guest_params) {
   bool old_auto_size_enabled = auto_size_enabled_;
   gfx::Size old_max_size = max_auto_size_;
   gfx::Size old_min_size = min_auto_size_;
   auto_size_enabled_ = auto_size_params.enable;
@@ skipping 144 matching lines @@
   RenderViewHostImpl* embedder_render_view_host =
       static_cast<RenderViewHostImpl*>(
           embedder_web_contents_->GetRenderViewHost());
   CHECK(embedder_render_view_host);
   RenderViewHostDelegateView* view =
       embedder_render_view_host->GetDelegate()->GetDelegateView();
   if (view)
     view->UpdateDragCursor(operation);
 }
 
-void BrowserPluginGuest::OnUpdateFrameName(int frame_id,
-                                           bool is_top_level,
-                                           const std::string& name) {
-  if (!is_top_level)
-    return;
-
-  name_ = name;
-  SendMessageToEmbedder(new BrowserPluginMsg_UpdatedName(instance_id_, name));
-}
-
 void BrowserPluginGuest::RequestMediaAccessPermission(
     WebContents* web_contents,
     const MediaStreamRequest& request,
     const MediaResponseCallback& callback) {
   if (media_requests_map_.size() >= kNumMaxOutstandingPermissionRequests) {
     // Deny the media request.
     callback.Run(MediaStreamDevices());
     return;
   }
   int request_id = next_permission_request_id_++;
@@ skipping 174 matching lines @@
                    base::Value::CreateStringValue(request_method));
   request_info.Set(browser_plugin::kURL, base::Value::CreateStringValue(url));
 
   SendMessageToEmbedder(
       new BrowserPluginMsg_RequestPermission(instance_id(),
           BrowserPluginPermissionTypeDownload, permission_request_id,
           request_info));
 }
 
 }  // namespace content