Added the infrastructure for surfaceProxy.onResize() and SurfaceView.onResize()

extensions/browser/guest_view/guest_view_base.cc

 // Copyright 2014 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 "extensions/browser/guest_view/guest_view_base.h"
 
 #include "base/lazy_instance.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/ui/zoom/zoom_controller.h"
 #include "content/public/browser/navigation_details.h"
@@ skipping 207 matching lines @@
   create_params.GetInteger(guestview::kParameterInstanceId,
                            &view_instance_id_);
 
   if (CanRunInDetachedState())
     SetUpAutoSize(create_params);
 
   // Give the derived class an opportunity to perform additional initialization.
   DidInitialize(create_params);
 }
 
+void GuestViewBase::DispatchOnResizeEvent(const gfx::Size& old_size,
+                                          const gfx::Size& new_size) {
+  if (new_size == old_size)
+    return;
+
+  // Dispatch the onResize event.
+  scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
+  args->SetInteger(guestview::kOldWidth, old_size.width());
+  args->SetInteger(guestview::kOldHeight, old_size.height());
+  args->SetInteger(guestview::kNewWidth, new_size.width());
+  args->SetInteger(guestview::kNewHeight, new_size.height());
+  DispatchEventToGuestProxy(new Event(guestview::kEventResize, args.Pass()));
+}
+
 void GuestViewBase::SetAutoSize(bool enabled,
                                 const gfx::Size& min_size,
                                 const gfx::Size& max_size) {
   min_auto_size_ = min_size;
   min_auto_size_.SetToMin(max_size);
   max_auto_size_ = max_size;
   max_auto_size_.SetToMax(min_size);
 
   enabled &= !min_auto_size_.IsEmpty() && !max_auto_size_.IsEmpty() &&
       IsAutoSizeSupported();
   if (!enabled && !auto_size_enabled_)
     return;
 
   auto_size_enabled_ = enabled;
 
   if (!attached() && !CanRunInDetachedState())
     return;
 
   content::RenderViewHost* rvh = web_contents()->GetRenderViewHost();
   if (auto_size_enabled_) {
     rvh->EnableAutoResize(min_auto_size_, max_auto_size_);
   } else {
     rvh->DisableAutoResize(element_size_);
+    DispatchOnResizeEvent(guest_size_, element_size_);
+    GuestSizeChangedDueToAutoSize(guest_size_, element_size_);
     guest_size_ = element_size_;
-    GuestSizeChangedDueToAutoSize(guest_size_, element_size_);
   }
 }
 
 // static
 void GuestViewBase::RegisterGuestViewType(
     const std::string& view_type,
     const GuestCreationCallback& callback) {
   GuestViewCreationMap::iterator it =
       guest_view_registry.Get().find(view_type);
   DCHECK(it == guest_view_registry.Get().end());
@@ skipping 95 matching lines @@
   StopTrackingEmbedderZoomLevel();
   owner_web_contents()->Send(new ExtensionMsg_GuestDetached(
       element_instance_id_));
   element_instance_id_ = guestview::kInstanceIDNone;
 }
 
 void GuestViewBase::ElementSizeChanged(const gfx::Size& size) {
   element_size_ = size;
 
   // Only resize if needed.
-  if (!size.IsEmpty())
+  if (!size.IsEmpty()) {
     guest_sizer_->SizeContents(size);
+    guest_size_ = size;
+  }
 }
 
 WebContents* GuestViewBase::GetOwnerWebContents() const {
   return owner_web_contents_;
 }
 
 void GuestViewBase::GuestSizeChanged(const gfx::Size& old_size,
                                      const gfx::Size& new_size) {
+  DispatchOnResizeEvent(old_size, new_size);
   if (!auto_size_enabled_)
     return;
   guest_size_ = new_size;
   GuestSizeChangedDueToAutoSize(old_size, new_size);
 }
 
 const GURL& GuestViewBase::GetOwnerSiteURL() const {
   return owner_web_contents()->GetLastCommittedURL();
 }
 
@@ skipping 163 matching lines @@
 void GuestViewBase::OnZoomChanged(
     const ui_zoom::ZoomController::ZoomChangedEventData& data) {
   if (content::ZoomValuesEqual(data.old_zoom_level, data.new_zoom_level))
     return;
   // When the embedder's zoom level is changed, then we also update the
   // guest's zoom level to match.
   ui_zoom::ZoomController::FromWebContents(web_contents())
       ->SetZoomLevel(data.new_zoom_level);
 }
 
-void GuestViewBase::DispatchEventToEmbedder(Event* event) {
-  scoped_ptr<Event> event_ptr(event);
+void GuestViewBase::DispatchEventToGuestProxy(Event* event) {
+  DispatchEvent(event, guest_instance_id_);
+}
 
+void GuestViewBase::DispatchEventToView(Event* event) {
   if (!attached() &&
       (!CanRunInDetachedState() || !can_owner_receive_events())) {
-    pending_events_.push_back(linked_ptr<Event>(event_ptr.release()));
+    pending_events_.push_back(linked_ptr<Event>(event));
     return;
   }
 
+  DispatchEvent(event, view_instance_id_);
+}
+
+void GuestViewBase::DispatchEvent(Event* event, int instance_id) {
+  scoped_ptr<Event> event_ptr(event);
+
   EventFilteringInfo info;
-  info.SetInstanceID(view_instance_id_);
+  info.SetInstanceID(instance_id);
   scoped_ptr<base::ListValue> args(new base::ListValue());
   args->Append(event->GetArguments().release());
 
   EventRouter::DispatchEvent(
       owner_web_contents_,
       browser_context_,
       owner_extension_id_,
       event->name(),
       args.Pass(),
       EventRouter::USER_GESTURE_UNKNOWN,
       info);
 }
 
 void GuestViewBase::SendQueuedEvents() {
   if (!attached())
     return;
   while (!pending_events_.empty()) {
     linked_ptr<Event> event_ptr = pending_events_.front();
     pending_events_.pop_front();
-    DispatchEventToEmbedder(event_ptr.release());
+    DispatchEvent(event_ptr.release(), view_instance_id_);
   }
 }
 
 void GuestViewBase::CompleteInit(
     scoped_ptr<base::DictionaryValue> create_params,
     const WebContentsCreatedCallback& callback,
     content::WebContents* guest_web_contents) {
   if (!guest_web_contents) {
     // The derived class did not create a WebContents so this class serves no
     // purpose. Let's self-destruct.
@@ skipping 57 matching lines @@
 // static
 void GuestViewBase::RegisterGuestViewTypes() {
   AppViewGuest::Register();
   ExtensionOptionsGuest::Register();
   MimeHandlerViewGuest::Register();
   SurfaceWorkerGuest::Register();
   WebViewGuest::Register();
 }
 
 }  // namespace extensions