Browser Plugin: Implement AutoSize

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 32 matching lines @@
 
 namespace {
 const char kExitEventName[] = "exit";
 const char kIsTopLevel[] = "isTopLevel";
 const char kLoadAbortEventName[] = "loadabort";
 const char kLoadCommitEventName[] = "loadcommit";
 const char kLoadRedirectEventName[] = "loadredirect";
 const char kLoadStartEventName[] = "loadstart";
 const char kLoadStopEventName[] = "loadstop";
 const char kNewURL[] = "newUrl";
+const char kNewHeight[] = "newHeight";
+const char kNewWidth[] = "newWidth";
 const char kOldURL[] = "oldUrl";
+const char kOldHeight[] = "oldHeight";
+const char kOldWidth[] = "oldWidth";
 const char kPartitionAttribute[] = "partition";
 const char kPersistPrefix[] = "persist:";
 const char kProcessId[] = "processId";
+const char kSizeChangedEventName[] = "sizechanged";
 const char kSrcAttribute[] = "src";
 const char kType[] = "type";
 const char kURL[] = "url";
 
 static std::string TerminationStatusToString(base::TerminationStatus status) {
   switch (status) {
     case base::TERMINATION_STATUS_NORMAL_TERMINATION:
       return "normal";
     case base::TERMINATION_STATUS_ABNORMAL_TERMINATION:
       return "abnormal";
@@ skipping 26 matching lines @@
       auto_size_(false),
       max_height_(0),
       max_width_(0),
       min_height_(0),
       min_width_(0),
       process_id_(-1),
       persist_storage_(false),
       content_window_routing_id_(MSG_ROUTING_NONE),
       focused_(false),
       visible_(true),
+      size_changed_in_flight_(false),
       current_nav_entry_index_(0),
       nav_entry_count_(0) {
   BrowserPluginManager::Get()->AddBrowserPlugin(instance_id, this);
   bindings_.reset(new BrowserPluginBindings(this));
 
   InitializeEvents();
 
   ParseAttributes(params);
 }
 
@@ skipping 48 matching lines @@
   // 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;
 }
 
 void BrowserPlugin::SetAutoSizeAttribute(bool auto_size) {
   if (auto_size_ == auto_size)
     return;
   auto_size_ = auto_size;
+  last_view_size_ = plugin_rect_.size();
   UpdateGuestAutoSizeState();
 }
 
 void BrowserPlugin::PopulateAutoSizeParameters(
-    BrowserPluginHostMsg_AutoSize_Params* params) const {
+    BrowserPluginHostMsg_AutoSize_Params* params) {
+  // If maxWidth or maxHeight have not been set, set them to the container size.
+  max_height_ = max_height_ ? max_height_ : height();
+  max_width_ = max_width_ ? max_width_ : width();
+  // minWidth should not be bigger than maxWidth, and minHeight should not be
+  // bigger than maxHeight.
+  min_height_ = std::min(min_height_, max_height_);
+  min_width_ = std::min(min_width_, max_width_);
   params->enable = auto_size_;
-  params->max_height = max_height_;
-  params->max_width = max_width_;
-  params->min_height = min_height_;
-  params->min_width = min_width_;
+  params->max_size = gfx::Size(max_width_, max_height_);
+  params->min_size = gfx::Size(min_width_, min_height_);
 }
 
-void BrowserPlugin::UpdateGuestAutoSizeState() const {
+void BrowserPlugin::UpdateGuestAutoSizeState() {
   if (!navigate_src_sent_)
     return;
-  BrowserPluginHostMsg_AutoSize_Params params;
-  PopulateAutoSizeParameters(&params);
+  BrowserPluginHostMsg_AutoSize_Params auto_size_params;
+  PopulateAutoSizeParameters(&auto_size_params);
+  BrowserPluginHostMsg_ResizeGuest_Params resize_params;
+  int view_width = auto_size_params.max_size.width();
+  int view_height = auto_size_params.max_size.height();
+  if (!auto_size_params.enable) {
+    view_width = width();
+    view_height = height();
+  }
+  TransportDIB* new_damage_buffer =
+      PopulateResizeGuestParameters(&resize_params, view_width, view_height);
+  // AutoSize initiates a resize so we don't want to issue another resize,
+  // we just want to make sure the damage buffer has been updated.
+  resize_params.resize_pending = true;
+  DCHECK(new_damage_buffer);
   BrowserPluginManager::Get()->Send(new BrowserPluginHostMsg_SetAutoSize(
       render_view_routing_id_,
       instance_id_,
-      params));
+      auto_size_params,
+      resize_params));
+  if (damage_buffer_)
+    FreeDamageBuffer();
+  damage_buffer_ = new_damage_buffer;
+}
+
+void BrowserPlugin::SizeChangedDueToAutoSize(const gfx::Size& old_view_size) {
+  size_changed_in_flight_ = false;
+  if (!HasListeners(kSizeChangedEventName))
+    return;
+
+  WebKit::WebElement plugin = container()->element();
+  v8::HandleScope handle_scope;
+  v8::Context::Scope context_scope(
+      plugin.document().frame()->mainWorldScriptContext());
+
+  // Construct the sizechanged event object.
+  v8::Local<v8::Object> event = v8::Object::New();
+  event->Set(v8::String::New(kOldHeight, sizeof(kOldHeight) - 1),
+             v8::Integer::New(old_view_size.height()),
+             v8::ReadOnly);
+  event->Set(v8::String::New(kOldWidth, sizeof(kOldWidth) - 1),
+             v8::Integer::New(old_view_size.width()),
+             v8::ReadOnly);
+  event->Set(v8::String::New(kNewHeight, sizeof(kNewHeight) - 1),
+             v8::Integer::New(last_view_size_.height()),
+             v8::ReadOnly);
+  event->Set(v8::String::New(kNewWidth, sizeof(kNewWidth) - 1),
+             v8::Integer::New(last_view_size_.width()),
+             v8::ReadOnly);
+  TriggerEvent(kSizeChangedEventName, &event);
 }
 
 void BrowserPlugin::SetMaxHeightAttribute(int max_height) {
   if (max_height_ == max_height)
     return;
   max_height_ = max_height;
   if (!auto_size_)
     return;
   UpdateGuestAutoSizeState();
 }
@@ skipping 18 matching lines @@
 
 void BrowserPlugin::SetMinWidthAttribute(int min_width) {
   if (min_width_ == min_width)
     return;
   min_width_ = min_width;
   if (!auto_size_)
      return;
   UpdateGuestAutoSizeState();
 }
 
+bool BrowserPlugin::InAutoSizeBounds(const gfx::Size& size) const {
+  return size.width() <= max_width_ && size.height() <= max_height_;
+}
+
 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 73 matching lines @@
   return render_view_->GetWebView()->deviceScaleFactor();
 }
 
 void BrowserPlugin::InitializeEvents() {
   event_listener_map_[kExitEventName] = EventListeners();
   event_listener_map_[kLoadAbortEventName] = EventListeners();
   event_listener_map_[kLoadCommitEventName] = EventListeners();
   event_listener_map_[kLoadRedirectEventName] = EventListeners();
   event_listener_map_[kLoadStartEventName] = EventListeners();
   event_listener_map_[kLoadStopEventName] = EventListeners();
+  event_listener_map_[kSizeChangedEventName] = EventListeners();
 }
 
 void BrowserPlugin::RemoveEventListeners() {
   EventListenerMap::iterator event_listener_map_iter =
       event_listener_map_.begin();
   for (; event_listener_map_iter != event_listener_map_.end();
        ++event_listener_map_iter) {
     EventListeners& listeners =
         event_listener_map_[event_listener_map_iter->first];
     EventListeners::iterator it = listeners.begin();
@@ skipping 87 matching lines @@
   if (!navigate_src_sent_)
     return;
   BrowserPluginManager::Get()->Send(
       new BrowserPluginHostMsg_Reload(render_view_routing_id_,
                                       instance_id_));
 }
 
 void BrowserPlugin::UpdateRect(
     int message_id,
     const BrowserPluginMsg_UpdateRect_Params& params) {
-  if (width() != params.view_size.width() ||
-      height() != params.view_size.height()) {
+  if ((!auto_size_ &&
+       (width() != params.view_size.width() ||
+        height() != params.view_size.height())) ||
+      (auto_size_ && (!InAutoSizeBounds(params.view_size)))) {
     BrowserPluginManager::Get()->Send(new BrowserPluginHostMsg_UpdateRect_ACK(
         render_view_routing_id_,
         instance_id_,
         message_id,
         gfx::Size(width(), height())));
     return;
   }
+  // If the view size has changed since we last updated.
+  if (auto_size_ && (params.view_size != last_view_size_)) {
+    if (backing_store_)
+      backing_store_->Clear(SK_ColorWHITE);
+    gfx::Size old_view_size = last_view_size_;
+    last_view_size_ = params.view_size;
+    // Schedule a SizeChanged instead of calling it directly to ensure that
+    // the backing store has been updated before the developer attempts to
+    // resize to avoid flicker. |size_changed_in_flight_| acts as a form of
+    // flow control for SizeChanged events. If the guest's view size is changing
+    // rapidly before a SizeChanged event fires, then we avoid scheduling
+    // another SizedChanged event. SizedChanged reads the new size from
+    // |last_view_size_| so we can be sure that it always fires an event
+    // with the last seen view size.
+    if (container_ && !size_changed_in_flight_) {
+      size_changed_in_flight_ = true;
+      MessageLoop::current()->PostTask(
+          FROM_HERE,
+          base::Bind(&BrowserPlugin::SizeChangedDueToAutoSize,
+                     base::Unretained(this),
+                     old_view_size));
+   }
+  }
 
   float backing_store_scale_factor =
       backing_store_.get() ? backing_store_->GetScaleFactor() : 1.0f;
 
-  if (params.is_resize_ack ||
-      backing_store_scale_factor != params.scale_factor) {
+  if (!backing_store_ || params.is_resize_ack ||
+      (backing_store_scale_factor != params.scale_factor) ||
+      params.view_size.width() > backing_store_->GetSize().width() ||
+      params.view_size.height() > backing_store_->GetSize().height()) {
+    int backing_store_width = auto_size_ ? max_width_ : width();
+    int backing_store_height = auto_size_ ? max_height_: height();
     resize_pending_ = !params.is_resize_ack;
     backing_store_.reset(
-        new BrowserPluginBackingStore(gfx::Size(width(), height()),
-                                      params.scale_factor));
+        new BrowserPluginBackingStore(
+            gfx::Size(backing_store_width, backing_store_height),
+            params.scale_factor));
   }
 
   // Update the backing store.
   if (!params.scroll_rect.IsEmpty()) {
     backing_store_->ScrollBackingStore(params.dx,
                                        params.dy,
                                        params.scroll_rect,
                                        params.view_size);
   }
   for (unsigned i = 0; i < params.copy_rects.size(); i++) {
@@ skipping 287 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 (auto_size_ || (old_width == window_rect.width &&
-                    old_height == window_rect.height)) {
+                     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 *
-                                   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 = CreateTransportDIB(size);
   pending_resize_params_.reset();
 
   scoped_ptr<BrowserPluginHostMsg_ResizeGuest_Params> params(
       new BrowserPluginHostMsg_ResizeGuest_Params);
-  params->damage_buffer_id = new_damage_buffer->id();
-#if defined(OS_MACOSX)
-  // |damage_buffer_id| is not enough to retrieve the damage buffer (on browser
-  // side) since we don't let the browser cache the damage buffer. We need a
-  // handle to the damage buffer for this.
-  params->damage_buffer_handle = new_damage_buffer->handle();
-#endif
-#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();
+
+  TransportDIB* new_damage_buffer =
+      PopulateResizeGuestParameters(params.get(), width(), height());
+  DCHECK(new_damage_buffer);
 
   if (navigate_src_sent_) {
     BrowserPluginManager::Get()->Send(new BrowserPluginHostMsg_ResizeGuest(
         render_view_routing_id_,
         instance_id_,
         *params));
     resize_pending_ = true;
   } else {
     // Until an actual navigation occurs, there is no browser-side embedder
     // present to notify about geometry updates. In this case, after we've
@@ skipping 12 matching lines @@
   // We don't need to (nor should we) send ViewHostMsg_FreeTransportDIB
   // message to the browser to free the damage buffer since we manage the
   // damage buffer ourselves.
   delete damage_buffer_;
 #else
   RenderProcess::current()->FreeTransportDIB(damage_buffer_);
   damage_buffer_ = NULL;
 #endif
 }
 
+TransportDIB* BrowserPlugin::PopulateResizeGuestParameters(
+    BrowserPluginHostMsg_ResizeGuest_Params* params,
+    int view_width, int view_height) {
+  const size_t stride = skia::PlatformCanvas::StrideForWidth(view_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>(view_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 = CreateTransportDIB(size);
+  params->damage_buffer_id = new_damage_buffer->id();
+#if defined(OS_MACOSX)
+  // |damage_buffer_id| is not enough to retrieve the damage buffer (on browser
+  // side) since we don't let the browser cache the damage buffer. We need a
+  // handle to the damage buffer for this.
+  params->damage_buffer_handle = new_damage_buffer->handle();
+#endif
+#if defined(OS_WIN)
+  params->damage_buffer_size = size;
+#endif
+  params->width = view_width;
+  params->height = view_height;
+  params->resize_pending = resize_pending_;
+  params->scale_factor = GetDeviceScaleFactor();
+  return new_damage_buffer;
+}
+
 BrowserPluginHostMsg_ResizeGuest_Params*
     BrowserPlugin::GetPendingResizeParams() {
   if (pending_resize_params_.get()) {
     resize_pending_ = true;
     return pending_resize_params_.release();
   } else {
     BrowserPluginHostMsg_ResizeGuest_Params* params =
         new BrowserPluginHostMsg_ResizeGuest_Params;
 
     // We don't have a pending resize to send, so we send an invalid transport
@@ skipping 121 matching lines @@
                                                  void* notify_data) {
 }
 
 void BrowserPlugin::didFailLoadingFrameRequest(
     const WebKit::WebURL& url,
     void* notify_data,
     const WebKit::WebURLError& error) {
 }
 
 }  // namespace content