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

extensions/browser/guest_view/web_view/web_view_guest.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/web_view/web_view_guest.h"
 
 #include "base/message_loop/message_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/public/browser/browser_context.h"
@@ skipping 302 matching lines @@
 }
 
 void WebViewGuest::AttachWebViewHelpers(WebContents* contents) {
   if (web_view_guest_delegate_)
     web_view_guest_delegate_->OnAttachWebViewHelpers(contents);
   web_view_permission_helper_.reset(new WebViewPermissionHelper(this));
 }
 
 void WebViewGuest::DidStopLoading() {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
-  DispatchEventToEmbedder(
+  DispatchEventToView(
       new GuestViewBase::Event(webview::kEventLoadStop, args.Pass()));
 }
 
 void WebViewGuest::EmbedderWillBeDestroyed() {
   // Clean up rules registries for the webview.
   RulesRegistryService::Get(browser_context())
       ->RemoveRulesRegistriesByID(rules_registry_id_);
   WebViewKey key(owner_web_contents()->GetRenderProcessHost()->GetID(),
                  view_instance_id());
   web_view_key_to_id_map.Get().erase(key);
@@ skipping 36 matching lines @@
   }
 }
 
 void WebViewGuest::GuestSizeChangedDueToAutoSize(const gfx::Size& old_size,
                                                  const gfx::Size& new_size) {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetInteger(webview::kOldHeight, old_size.height());
   args->SetInteger(webview::kOldWidth, old_size.width());
   args->SetInteger(webview::kNewHeight, new_size.height());
   args->SetInteger(webview::kNewWidth, new_size.width());
-  DispatchEventToEmbedder(
+  DispatchEventToView(
       new GuestViewBase::Event(webview::kEventSizeChanged, args.Pass()));
 }
 
 bool WebViewGuest::IsAutoSizeSupported() const {
   return true;
 }
 
 bool WebViewGuest::IsDragAndDropEnabled() const {
   return true;
 }
 
 void WebViewGuest::WillDestroy() {
   if (!attached() && GetOpener())
     GetOpener()->pending_new_windows_.erase(this);
 }
 
 bool WebViewGuest::AddMessageToConsole(WebContents* source,
                                        int32 level,
                                        const base::string16& message,
                                        int32 line_no,
                                        const base::string16& source_id) {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   // Log levels are from base/logging.h: LogSeverity.
   args->SetInteger(webview::kLevel, level);
   args->SetString(webview::kMessage, message);
   args->SetInteger(webview::kLine, line_no);
   args->SetString(webview::kSourceId, source_id);
-  DispatchEventToEmbedder(
+  DispatchEventToView(
       new GuestViewBase::Event(webview::kEventConsoleMessage, args.Pass()));
   return true;
 }
 
 void WebViewGuest::CloseContents(WebContents* source) {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
-  DispatchEventToEmbedder(
+  DispatchEventToView(
       new GuestViewBase::Event(webview::kEventClose, args.Pass()));
 }
 
 void WebViewGuest::FindReply(WebContents* source,
                              int request_id,
                              int number_of_matches,
                              const gfx::Rect& selection_rect,
                              int active_match_ordinal,
                              bool final_update) {
   find_helper_.FindReply(request_id,
@@ skipping 27 matching lines @@
   // See http://crbug.com/229882.
   embedder_web_contents()->GetDelegate()->HandleKeyboardEvent(
       web_contents(), event);
 }
 
 void WebViewGuest::LoadProgressChanged(content::WebContents* source,
                                        double progress) {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetString(guestview::kUrl, web_contents()->GetURL().spec());
   args->SetDouble(webview::kProgress, progress);
-  DispatchEventToEmbedder(
+  DispatchEventToView(
       new GuestViewBase::Event(webview::kEventLoadProgress, args.Pass()));
 }
 
 void WebViewGuest::LoadAbort(bool is_top_level,
                              const GURL& url,
                              const std::string& error_type) {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetBoolean(guestview::kIsTopLevel, is_top_level);
   args->SetString(guestview::kUrl, url.possibly_invalid_spec());
   args->SetString(guestview::kReason, error_type);
-  DispatchEventToEmbedder(
+  DispatchEventToView(
       new GuestViewBase::Event(webview::kEventLoadAbort, args.Pass()));
 }
 
 void WebViewGuest::OnFrameNameChanged(bool is_top_level,
                                       const std::string& name) {
   if (!is_top_level)
     return;
 
   if (name_ == name)
     return;
@@ skipping 42 matching lines @@
                              params.user_gesture,
                              new_guest->web_contents());
 }
 
 // TODO(fsamuel): Find a reliable way to test the 'responsive' and
 // 'unresponsive' events.
 void WebViewGuest::RendererResponsive(content::WebContents* source) {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetInteger(webview::kProcessId,
                    web_contents()->GetRenderProcessHost()->GetID());
-  DispatchEventToEmbedder(
+  DispatchEventToView(
       new GuestViewBase::Event(webview::kEventResponsive, args.Pass()));
 }
 
 void WebViewGuest::RendererUnresponsive(content::WebContents* source) {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetInteger(webview::kProcessId,
                    web_contents()->GetRenderProcessHost()->GetID());
-  DispatchEventToEmbedder(
+  DispatchEventToView(
       new GuestViewBase::Event(webview::kEventUnresponsive, args.Pass()));
 }
 
 void WebViewGuest::Observe(int type,
                            const content::NotificationSource& source,
                            const content::NotificationDetails& details) {
   switch (type) {
     case content::NOTIFICATION_LOAD_COMPLETED_MAIN_FRAME: {
       DCHECK_EQ(content::Source<WebContents>(source).ptr(), web_contents());
       if (content::Source<WebContents>(source).ptr() == web_contents())
@@ skipping 124 matching lines @@
                       ->GetController()
                       .GetLastCommittedEntry()
                       ->GetBaseURLForDataURL()
                       .spec());
   args->SetInteger(webview::kInternalCurrentEntryIndex,
                    web_contents()->GetController().GetCurrentEntryIndex());
   args->SetInteger(webview::kInternalEntryCount,
                    web_contents()->GetController().GetEntryCount());
   args->SetInteger(webview::kInternalProcessId,
                    web_contents()->GetRenderProcessHost()->GetID());
-  DispatchEventToEmbedder(
+  DispatchEventToView(
       new GuestViewBase::Event(webview::kEventLoadCommit, args.Pass()));
 
   find_helper_.CancelAllFindSessions();
 
   // Update the current zoom factor for the new page.
   ui_zoom::ZoomController* zoom_controller =
       ui_zoom::ZoomController::FromWebContents(web_contents());
   DCHECK(zoom_controller);
   current_zoom_factor_ =
       content::ZoomLevelToZoomFactor(zoom_controller->GetZoomLevel());
@@ skipping 14 matching lines @@
 }
 
 void WebViewGuest::DidStartProvisionalLoadForFrame(
     content::RenderFrameHost* render_frame_host,
     const GURL& validated_url,
     bool is_error_page,
     bool is_iframe_srcdoc) {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetString(guestview::kUrl, validated_url.spec());
   args->SetBoolean(guestview::kIsTopLevel, !render_frame_host->GetParent());
-  DispatchEventToEmbedder(
+  DispatchEventToView(
       new GuestViewBase::Event(webview::kEventLoadStart, args.Pass()));
 }
 
 void WebViewGuest::DocumentLoadedInFrame(
     content::RenderFrameHost* render_frame_host) {
   if (web_view_guest_delegate_)
     web_view_guest_delegate_->OnDocumentLoadedInFrame(render_frame_host);
 }
 
 bool WebViewGuest::OnMessageReceived(const IPC::Message& message,
                                      RenderFrameHost* render_frame_host) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(WebViewGuest, message)
     IPC_MESSAGE_HANDLER(ExtensionHostMsg_FrameNameChanged, OnFrameNameChanged)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void WebViewGuest::RenderProcessGone(base::TerminationStatus status) {
   // Cancel all find sessions in progress.
   find_helper_.CancelAllFindSessions();
 
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetInteger(webview::kProcessId,
                    web_contents()->GetRenderProcessHost()->GetID());
   args->SetString(webview::kReason, TerminationStatusToString(status));
-  DispatchEventToEmbedder(
+  DispatchEventToView(
       new GuestViewBase::Event(webview::kEventExit, args.Pass()));
 }
 
 void WebViewGuest::UserAgentOverrideSet(const std::string& user_agent) {
   content::NavigationController& controller = web_contents()->GetController();
   content::NavigationEntry* entry = controller.GetVisibleEntry();
   if (!entry)
     return;
   entry->SetIsOverridingUserAgent(!user_agent.empty());
   web_contents()->GetController().Reload(false);
 }
 
 void WebViewGuest::ReportFrameNameChange(const std::string& name) {
   name_ = name;
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetString(webview::kName, name);
-  DispatchEventToEmbedder(
+  DispatchEventToView(
       new GuestViewBase::Event(webview::kEventFrameNameChanged, args.Pass()));
 }
 
 void WebViewGuest::LoadHandlerCalled() {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
-  DispatchEventToEmbedder(
+  DispatchEventToView(
       new GuestViewBase::Event(webview::kEventContentLoad, args.Pass()));
 }
 
 void WebViewGuest::LoadRedirect(const GURL& old_url,
                                 const GURL& new_url,
                                 bool is_top_level) {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetBoolean(guestview::kIsTopLevel, is_top_level);
   args->SetString(webview::kNewURL, new_url.spec());
   args->SetString(webview::kOldURL, old_url.spec());
-  DispatchEventToEmbedder(
+  DispatchEventToView(
       new GuestViewBase::Event(webview::kEventLoadRedirect, args.Pass()));
 }
 
 void WebViewGuest::PushWebViewStateToIOThread() {
   const GURL& site_url = web_contents()->GetSiteInstance()->GetSiteURL();
   std::string partition_domain;
   std::string partition_id;
   bool in_memory;
   if (!GetGuestPartitionConfigForSite(
           site_url, &partition_domain, &partition_id, &in_memory)) {
@@ skipping 241 matching lines @@
 void WebViewGuest::SetZoom(double zoom_factor) {
   ui_zoom::ZoomController* zoom_controller =
       ui_zoom::ZoomController::FromWebContents(web_contents());
   DCHECK(zoom_controller);
   double zoom_level = content::ZoomFactorToZoomLevel(zoom_factor);
   zoom_controller->SetZoomLevel(zoom_level);
 
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetDouble(webview::kOldZoomFactor, current_zoom_factor_);
   args->SetDouble(webview::kNewZoomFactor, zoom_factor);
-  DispatchEventToEmbedder(
+  DispatchEventToView(
       new GuestViewBase::Event(webview::kEventZoomChange, args.Pass()));
   current_zoom_factor_ = zoom_factor;
 }
 
 void WebViewGuest::SetAllowTransparency(bool allow) {
   if (guest_opaque_ != allow)
     return;
 
   guest_opaque_ = !allow;
   if (!web_contents()->GetRenderViewHost()->GetView())
@@ skipping 186 matching lines @@
       WebViewGuest::From(owner_web_contents()->GetRenderProcessHost()->GetID(),
                          new_window_instance_id);
   if (!guest)
     return;
 
   if (!allow)
     guest->Destroy();
 }
 
 }  // namespace extensions