Browser Plugin: Implement autosize (Embedder-side code)

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"
@@ skipping 72 matching lines @@
     const WebPluginParams& params)
     : instance_id_(instance_id),
       render_view_(render_view->AsWeakPtr()),
       render_view_routing_id_(render_view->GetRoutingID()),
       container_(NULL),
       damage_buffer_(NULL),
       sad_guest_(NULL),
       guest_crashed_(false),
       resize_pending_(false),
       navigate_src_sent_(false),
+      autosize_(false),
+      maxheight_(0),
+      maxwidth_(0),
+      minheight_(0),
+      minwidth_(0),
       process_id_(-1),
       persist_storage_(false),
       content_window_routing_id_(MSG_ROUTING_NONE),
       focused_(false),
       visible_(true),
       current_nav_entry_index_(0),
       nav_entry_count_(0) {
   BrowserPluginManager::Get()->AddBrowserPlugin(instance_id, this);
   bindings_.reset(new BrowserPluginBindings(this));
 
@@ skipping 23 matching lines @@
 }
 
 void BrowserPlugin::SetSrcAttribute(const std::string& src) {
   if (src.empty() || (src == src_ && !guest_crashed_))
     return;
 
   // 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
   // acutally need it.
   if (!navigate_src_sent_) {
+    BrowserPluginHostMsg_CreateGuest_Params params;
+    params.storage_partition_id = storage_partition_id_;
+    params.persist_storage = persist_storage_;
+    params.focused = focused_;
+    params.visible = visible_;
+    PopulateAutoSizeParameters(&params.autosize);
     BrowserPluginManager::Get()->Send(
         new BrowserPluginHostMsg_CreateGuest(
             render_view_routing_id_,
             instance_id_,
-            storage_partition_id_,
-            persist_storage_,
-            focused_,
-            visible_));
+            params));
   }
 
   scoped_ptr<BrowserPluginHostMsg_ResizeGuest_Params> params(
       GetPendingResizeParams());
   DCHECK(!params->resize_pending);
 
   BrowserPluginManager::Get()->Send(
       new BrowserPluginHostMsg_NavigateGuest(
           render_view_routing_id_,
           instance_id_,
           src,
           *params));
   // Record that we sent a NavigateGuest message to embedder.
   // Once this instance has navigated, the storage partition cannot be changed,
   // so this value is used for enforcing this.
   navigate_src_sent_ = true;
   src_ = src;
 }
 
+bool BrowserPlugin::GetAutoSizeAttribute() const {
+  return autosize_;
+}
+
+void BrowserPlugin::SetAutoSizeAttribute(bool autosize) {
+  if (autosize_ == autosize)
+    return;
+  autosize_ = autosize;
+  UpdateGuestAutoSizeState();
+}
+
+void BrowserPlugin::PopulateAutoSizeParameters(
+    BrowserPluginHostMsg_AutoSize_Params* params) const {
+  params->enable = autosize_;
+  params->maxheight = maxheight_;
+  params->maxwidth = maxwidth_;
+  params->minheight = minheight_;
+  params->minwidth = minwidth_;
+}
+
+void BrowserPlugin::UpdateGuestAutoSizeState() const {
+  if (!navigate_src_sent_)
+    return;
+  BrowserPluginHostMsg_AutoSize_Params params;
+  PopulateAutoSizeParameters(&params);
+  BrowserPluginManager::Get()->Send(new BrowserPluginHostMsg_SetAutoSize(
+      render_view_routing_id_,
+      instance_id_,
+      params));
+}
+
+int BrowserPlugin::GetMaxHeightAttribute() const {

[jam, 2012/11/02 19:11:10]

nit: all these getters should jus be unix_hacker style methods in the header,
i.e. int max_height_attribute() const { return max_height_; }

[Fady Samuel, 2012/11/02 20:32:23]

Done.

+  return maxheight_;
+}
+
+void BrowserPlugin::SetMaxHeightAttribute(int maxheight) {
+  if (maxheight_ == maxheight)
+    return;
+  maxheight_ = maxheight;
+  if (!autosize_)
+    return;
+  UpdateGuestAutoSizeState();
+}
+
+int BrowserPlugin::GetMaxWidthAttribute() const {
+  return maxwidth_;
+}
+
+void BrowserPlugin::SetMaxWidthAttribute(int maxwidth) {
+  if (maxwidth_ == maxwidth)
+    return;
+  maxwidth_ = maxwidth;
+  if (!autosize_)
+    return;
+  UpdateGuestAutoSizeState();
+}
+
+int BrowserPlugin::GetMinHeightAttribute() const {
+  return minheight_;
+}
+
+void BrowserPlugin::SetMinHeightAttribute(int minheight) {
+  if (minheight_ == minheight)
+    return;
+  minheight_ = minheight;
+  if (!autosize_)
+     return;
+  UpdateGuestAutoSizeState();
+}
+
+int BrowserPlugin::GetMinWidthAttribute() const {
+  return minwidth_;
+}
+
+void BrowserPlugin::SetMinWidthAttribute(int minwidth) {
+  if (minwidth_ == minwidth)
+    return;
+  minwidth_ = minwidth;
+  if (!autosize_)
+     return;
+  UpdateGuestAutoSizeState();
+}
+
 NPObject* BrowserPlugin::GetContentWindow() const {
   if (content_window_routing_id_ == MSG_ROUTING_NONE)
     return NULL;
   RenderViewImpl* guest_render_view = static_cast<RenderViewImpl*>(
       ChildThread::current()->ResolveRoute(content_window_routing_id_));
   if (!guest_render_view)
     return NULL;
   WebKit::WebFrame* guest_frame = guest_render_view->GetWebView()->mainFrame();
   return guest_frame->windowObject();
 }
@@ skipping 98 matching lines @@
 }
 
 bool BrowserPlugin::IsValidEvent(const std::string& event_name) {
   return event_listener_map_.find(event_name) != event_listener_map_.end();
 }
 
 void BrowserPlugin::TriggerEvent(const std::string& event_name,
                                  v8::Local<v8::Object>* event) {
   WebKit::WebElement plugin = container()->element();
 
-  // TODO(fsamuel): Copying the event listeners is insufficent because
-  // new persistent handles are not created when the copy constructor is
-  // called. See http://crbug.com/155044.
   const EventListeners& listeners = event_listener_map_[event_name.c_str()];
   // A v8::Local copy of the listeners is created from the v8::Persistent
   // listeners before firing them. This is to ensure that if one of these
   // listeners mutate the list of listeners (by calling
   // addEventListener/removeEventListener), this local copy is not affected.
   // This means if you mutate the list of listeners for an event X while event X
   // is firing, the mutation is deferred until all current listeners for X have
   // fired.
   EventListenersLocal listeners_local;
   listeners_local.reserve(listeners.size());
@@ skipping 387 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) {
+  if (autosize_ || (old_width == window_rect.width &&
+                    old_height == window_rect.height)) {
     return;
   }
 
   const size_t stride = skia::PlatformCanvas::StrideForWidth(window_rect.width);
   // 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 *
@@ skipping 187 matching lines @@
                                                  void* notify_data) {
 }
 
 void BrowserPlugin::didFailLoadingFrameRequest(
     const WebKit::WebURL& url,
     void* notify_data,
     const WebKit::WebURLError& error) {
 }
 
 }  // namespace content