Browser Plugin: <webview> should inherit partition attribute of opener on attachment.

content/renderer/browser_plugin/browser_plugin.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/renderer/browser_plugin/browser_plugin.h"
 
 #include "base/command_line.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/message_loop.h"
 #include "base/string_number_conversions.h"
@@ skipping 123 matching lines @@
       guest_crashed_(false),
       auto_size_ack_pending_(false),
       guest_process_id_(-1),
       guest_route_id_(-1),
       persist_storage_(false),
       valid_partition_id_(true),
       content_window_routing_id_(MSG_ROUTING_NONE),
       plugin_focused_(false),
       visible_(true),
       size_changed_in_flight_(false),
-      allocate_instance_id_sent_(false),
+      before_first_navigation_(true),
       browser_plugin_manager_(render_view->browser_plugin_manager()),
       current_nav_entry_index_(0),
       nav_entry_count_(0),
       compositing_enabled_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           weak_ptr_factory_(this)) {
 }
 
 BrowserPlugin::~BrowserPlugin() {
   // If the BrowserPlugin has never navigated then the browser process and
@@ skipping 12 matching lines @@
     WebKit::WebPluginContainer* container) {
   PluginContainerMap* browser_plugins = g_plugin_container_map.Pointer();
   PluginContainerMap::iterator it = browser_plugins->find(container);
   return it == browser_plugins->end() ? NULL : it->second;
 }
 
 bool BrowserPlugin::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(BrowserPlugin, message)
     IPC_MESSAGE_HANDLER(BrowserPluginMsg_AdvanceFocus, OnAdvanceFocus)
+    IPC_MESSAGE_HANDLER(BrowserPluginMsg_Attach_ACK, OnAttachACK)
     IPC_MESSAGE_HANDLER(BrowserPluginMsg_BuffersSwapped, OnBuffersSwapped)
     IPC_MESSAGE_HANDLER_GENERIC(BrowserPluginMsg_CompositorFrameSwapped,
                                 OnCompositorFrameSwapped(message))
     IPC_MESSAGE_HANDLER(BrowserPluginMsg_GuestContentWindowReady,
                         OnGuestContentWindowReady)
     IPC_MESSAGE_HANDLER(BrowserPluginMsg_GuestGone, OnGuestGone)
     IPC_MESSAGE_HANDLER(BrowserPluginMsg_GuestResponsive, OnGuestResponsive)
     IPC_MESSAGE_HANDLER(BrowserPluginMsg_GuestUnresponsive, OnGuestUnresponsive)
     IPC_MESSAGE_HANDLER(BrowserPluginMsg_LoadAbort, OnLoadAbort)
     IPC_MESSAGE_HANDLER(BrowserPluginMsg_LoadCommit, OnLoadCommit)
@@ skipping 142 matching lines @@
   std::string src = GetSrcAttribute();
   if (src.empty())
     return true;
 
   // If we haven't created the guest yet, do so now. We will navigate it right
   // after creation. If |src| is empty, we can delay the creation until we
   // actually need it.
   if (!HasGuest()) {
     // On initial navigation, we request an instance ID from the browser
     // process. We essentially ignore all subsequent calls to SetSrcAttribute
-    // until we receive an instance ID. |allocate_instance_id_sent_|
+    // until we receive an instance ID. |before_first_navigation_|
     // prevents BrowserPlugin from allocating more than one instance ID.
     // Upon receiving an instance ID from the browser process, we continue
     // the process of navigation by populating the
     // BrowserPluginHostMsg_CreateGuest_Params with the current state of
     // BrowserPlugin and sending a BrowserPluginHostMsg_CreateGuest to the
     // browser process in order to create a new guest.
-    if (!allocate_instance_id_sent_) {
+    if (before_first_navigation_) {
       browser_plugin_manager()->AllocateInstanceID(this);
-      allocate_instance_id_sent_ = true;
+      before_first_navigation_ = false;
     }
     return true;
   }
 
   browser_plugin_manager()->Send(
       new BrowserPluginHostMsg_NavigateGuest(render_view_routing_id_,
                                              instance_id_,
                                              src));
   return true;
 }
@@ skipping 58 matching lines @@
 
 bool BrowserPlugin::UsesPendingDamageBuffer(
     const BrowserPluginMsg_UpdateRect_Params& params) {
   if (!pending_damage_buffer_.get())
     return false;
   return damage_buffer_sequence_id_ == params.damage_buffer_sequence_id;
 }
 
 void BrowserPlugin::SetInstanceID(int instance_id, bool new_guest) {
   CHECK(instance_id != browser_plugin::kInstanceIDNone);
+  before_first_navigation_ = false;
   instance_id_ = instance_id;
   browser_plugin_manager()->AddBrowserPlugin(instance_id, this);
 
   BrowserPluginHostMsg_CreateGuest_Params create_guest_params;
   create_guest_params.focused = ShouldGuestBeFocused();
   create_guest_params.visible = visible_;
   create_guest_params.name = GetNameAttribute();
   GetDamageBufferWithSizeParams(&create_guest_params.auto_size_params,
                                 &create_guest_params.resize_guest_params);
 
@@ skipping 16 matching lines @@
 void BrowserPlugin::DidCommitCompositorFrame() {
   if (compositing_helper_)
     compositing_helper_->DidCommitCompositorFrame();
 }
 
 void BrowserPlugin::OnAdvanceFocus(int instance_id, bool reverse) {
   DCHECK(render_view_);
   render_view_->GetWebView()->advanceFocus(reverse);
 }
 
+void BrowserPlugin::OnAttachACK(
+    int instance_id,
+    const BrowserPluginMsg_Attach_ACK_Params& params) {
+  // Update BrowserPlugin attributes to match the state of the guest.
+  if (!params.name.empty())
+    OnUpdatedName(instance_id, params.name);
+  if (!params.storage_partition_id.empty()) {
+    std::string partition_name =
+        (params.persist_storage ? browser_plugin::kPersistPrefix : "") +
+            params.storage_partition_id;
+    UpdateDOMAttribute(browser_plugin::kAttributePartition, partition_name);
+  }
+}
+
 void BrowserPlugin::OnBuffersSwapped(int instance_id,
                                      const gfx::Size& size,
                                      std::string mailbox_name,
                                      int gpu_route_id,
                                      int gpu_host_id) {
   DCHECK(instance_id == instance_id_);
   EnableCompositing(true);
 
   compositing_helper_->OnBuffersSwapped(size,
                                         mailbox_name,
@@ skipping 370 matching lines @@
 bool BrowserPlugin::CanGoBack() const {
   return nav_entry_count_ > 1 && current_nav_entry_index_ > 0;
 }
 
 bool BrowserPlugin::CanGoForward() const {
   return current_nav_entry_index_ >= 0 &&
       current_nav_entry_index_ < (nav_entry_count_ - 1);
 }
 
 bool BrowserPlugin::ParsePartitionAttribute(std::string* error_message) {
-  if (allocate_instance_id_sent_) {
+  if (!before_first_navigation_) {
     *error_message = browser_plugin::kErrorAlreadyNavigated;
     return false;
   }
 
   std::string input = GetPartitionAttribute();
 
   // Since the "persist:" prefix is in ASCII, StartsWith will work fine on
   // UTF-8 encoded |partition_id|. If the prefix is a match, we can safely
   // remove the prefix without splicing in the middle of a multi-byte codepoint.
   // We can use the rest of the string as UTF-8 encoded one.
@@ skipping 374 matching lines @@
   if (container_)
     return container_->windowToLocalPoint(WebKit::WebPoint(point));
   return gfx::Point(point.x() - plugin_rect_.x(), point.y() - plugin_rect_.y());
 }
 
 // static
 bool BrowserPlugin::ShouldForwardToBrowserPlugin(
     const IPC::Message& message) {
   switch (message.type()) {
     case BrowserPluginMsg_AdvanceFocus::ID:
+    case BrowserPluginMsg_Attach_ACK::ID:
     case BrowserPluginMsg_BuffersSwapped::ID:
     case BrowserPluginMsg_CompositorFrameSwapped::ID:
     case BrowserPluginMsg_GuestContentWindowReady::ID:
     case BrowserPluginMsg_GuestGone::ID:
     case BrowserPluginMsg_GuestResponsive::ID:
     case BrowserPluginMsg_GuestUnresponsive::ID:
     case BrowserPluginMsg_LoadAbort::ID:
     case BrowserPluginMsg_LoadCommit::ID:
     case BrowserPluginMsg_LoadRedirect::ID:
     case BrowserPluginMsg_LoadStart::ID:
@@ skipping 261 matching lines @@
     const WebKit::WebMouseEvent& event) {
   browser_plugin_manager()->Send(
       new BrowserPluginHostMsg_HandleInputEvent(render_view_routing_id_,
                                                 instance_id_,
                                                 plugin_rect_,
                                                 &event));
   return true;
 }
 
 }  // namespace content