Browser Plugin: New Implementation (Browser Side)

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/message_loop.h"
 #include "base/string_util.h"
+#if defined (OS_WIN)
+#include "base/sys_info.h"
+#endif
 #include "content/common/browser_plugin_messages.h"
 #include "content/public/common/content_client.h"
 #include "content/public/renderer/content_renderer_client.h"
 #include "content/renderer/browser_plugin/browser_plugin_bindings.h"
 #include "content/renderer/browser_plugin/browser_plugin_manager.h"
 #include "content/renderer/render_process_impl.h"
 #include "content/renderer/render_thread_impl.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebBindings.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
@@ skipping 28 matching lines @@
     RenderViewImpl* render_view,
     WebKit::WebFrame* frame,
     const WebPluginParams& params)
     : instance_id_(instance_id),
       render_view_(render_view),
       container_(NULL),
       damage_buffer_(NULL),
       sad_guest_(NULL),
       guest_crashed_(false),
       resize_pending_(false),
+      navigate_src_sent_(false),
       parent_frame_(frame->identifier()) {
   BrowserPluginManager::Get()->AddBrowserPlugin(instance_id, this);
   bindings_.reset(new BrowserPluginBindings(this));
 
   std::string src;
   if (ParseSrcAttribute(params, &src))
     SetSrcAttribute(src);
 }
 
 BrowserPlugin::~BrowserPlugin() {
@@ skipping 16 matching lines @@
   }
 }
 
 std::string BrowserPlugin::GetSrcAttribute() const {
   return src_;
 }
 
 void BrowserPlugin::SetSrcAttribute(const std::string& src) {
   if (src == src_ && !guest_crashed_)
     return;
-  if (!src.empty()) {
+  if (!src.empty() || navigate_src_sent_) {
     BrowserPluginManager::Get()->Send(
-        new BrowserPluginHostMsg_NavigateOrCreateGuest(
+        new BrowserPluginHostMsg_NavigateGuest(
             render_view_->GetRoutingID(),
             instance_id_,
             parent_frame_,
-            src));
+            src,
+            gfx::Size(width(), height())));
+    // Record that we sent a NavigateGuest message to embedder. Once we send
+    // such a message, subsequent SetSrcAttribute() calls must always send
+    // NavigateGuest messages to the embedder (even if |src| is empty), so
+    // resize works correctly for all cases (e.g. The embedder can reset the
+    // guest's |src| to empty value, resize and then set the |src| to a
+    // non-empty value).
+    navigate_src_sent_ = true;
   }
   src_ = src;
   guest_crashed_ = false;
 }
 
 bool BrowserPlugin::ParseSrcAttribute(
     const WebKit::WebPluginParams& params,
     std::string* src) {
   // Get the src attribute from the attributes vector
   for (unsigned i = 0; i < params.attributeNames.size(); ++i) {
@@ skipping 210 matching lines @@
 
 void BrowserPlugin::updateGeometry(
     const WebRect& window_rect,
     const WebRect& clip_rect,
     const WebVector<WebRect>& cut_outs_rects,
     bool is_visible) {
   int old_width = width();
   int old_height = height();
   plugin_rect_ = window_rect;
   if (old_width == window_rect.width &&
-      old_height == window_rect.height)
+      old_height == window_rect.height) {
+    return;
+  }
+  // Until an actual navigation occurs, there is no browser side embedder
+  // present to notify about geometry updates. In this case, after we've updated
+  // the BrowserPlugin's state we are done and can return immediately.
+  if (src_.empty() && !navigate_src_sent_)
     return;
 
   const size_t stride = skia::PlatformCanvas::StrideForWidth(window_rect.width);
-  const size_t size = window_rect.height *
-                      stride *
-                      GetDeviceScaleFactor() *
-                      GetDeviceScaleFactor();
+  // Make sure the size of the damage buffer is at least four bytes so that we
+  // can fit in a magic word to verify that the memory is shared correctly.
+  size_t size =
+      std::max(sizeof(unsigned int),
+               static_cast<size_t>(window_rect.height *
+                                   stride *
+                                   GetDeviceScaleFactor() *
+                                   GetDeviceScaleFactor()));
 
   // Don't drop the old damage buffer until after we've made sure that the
   // browser process has dropped it.
-  TransportDIB* new_damage_buffer =
-      RenderProcess::current()->CreateTransportDIB(size);
-  DCHECK(new_damage_buffer);
+  TransportDIB* new_damage_buffer = NULL;
+#if defined(OS_WIN)
+  size_t allocation_granularity = base::SysInfo::VMAllocationGranularity();
+  size_t shared_mem_size = size / allocation_granularity + 1;
+  shared_mem_size = shared_mem_size * allocation_granularity;
+
+  base::SharedMemory shared_mem;
+  if (!shared_mem.CreateAnonymous(shared_mem_size))
+    NOTREACHED() << "Unable to create shared memory of size:" << size;
+  new_damage_buffer = TransportDIB::Map(shared_mem.handle());
+#else
+  new_damage_buffer = RenderProcess::current()->CreateTransportDIB(size);
+#endif
+  if (!new_damage_buffer)
+    NOTREACHED() << "Unable to create damage buffer";
+  DCHECK(new_damage_buffer->memory());
+  // Insert the magic word.
+  *static_cast<unsigned int*>(new_damage_buffer->memory()) = 0xdeadbeef;
 
   BrowserPluginHostMsg_ResizeGuest_Params params;
   params.damage_buffer_id = new_damage_buffer->id();
+#if defined(OS_WIN)
+  params.damage_buffer_size = size;
+#endif
   params.width = window_rect.width;
   params.height = window_rect.height;
   params.resize_pending = resize_pending_;
   params.scale_factor = GetDeviceScaleFactor();
   BrowserPluginManager::Get()->Send(new BrowserPluginHostMsg_ResizeGuest(
       render_view_->GetRoutingID(),
       instance_id_,
       params));
   resize_pending_ = true;
 
@@ skipping 55 matching lines @@
                                                  void* notify_data) {
 }
 
 void BrowserPlugin::didFailLoadingFrameRequest(
     const WebKit::WebURL& url,
     void* notify_data,
     const WebKit::WebURLError& error) {
 }
 
 }  // namespace content