<webview>: Move autosize from content to chrome

chrome/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 "chrome/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 "chrome/browser/chrome_notification_types.h"
@@ skipping 279 matching lines @@
         embedder_render_process_host->GetBrowserContext(), guest_site);
   }
   WebContents::CreateParams params(
       embedder_render_process_host->GetBrowserContext(),
       guest_site_instance);
   params.guest_delegate = this;
   callback.Run(WebContents::Create(params));
 }
 
 void WebViewGuest::DidAttachToEmbedder() {
+  extra_params()->GetBoolean(webview::kAttributeAutoSize, &auto_size_enabled_);
+
+  int max_height = 0;
+  int max_width = 0;
+  extra_params()->GetInteger(webview::kAttributeMaxHeight, &max_height);

[lazyboy, 2014/07/31 04:24:22]

Do we need to DCHECK if GetInteger() returns true/false? We always expect these
values to be present right?

[Fady Samuel, 2014/08/01 18:12:52]

Well we just rely on these being the default values. I moved over to a call to
SetAutoSize where the clipping and validity checks are performed.

+  extra_params()->GetInteger(webview::kAttributeMaxWidth, &max_width);
+  max_auto_size_.SetSize(max_width, max_height);
+
+  int min_height = 0;
+  int min_width = 0;
+  extra_params()->GetInteger(webview::kAttributeMinHeight, &min_height);
+  extra_params()->GetInteger(webview::kAttributeMinWidth, &min_width);
+  min_auto_size_.SetSize(min_width, min_height);
+
   std::string name;
   if (extra_params()->GetString(webview::kName, &name)) {
     // If the guest window's name is empty, then the WebView tag's name is
     // assigned. Otherwise, the guest window's name takes precedence over the
     // WebView tag's name.
     if (name_.empty())
       name_ = name;
   }
   ReportFrameNameChange(name_);
 
@@ skipping 383 matching lines @@
 }
 
 WebViewGuest::WebViewGuest(content::BrowserContext* browser_context,
                            int guest_instance_id)
     : GuestView<WebViewGuest>(browser_context, guest_instance_id),
       pending_context_menu_request_id_(0),
       is_overriding_user_agent_(false),
       chromevox_injected_(false),
       current_zoom_factor_(1.0),
       find_helper_(this),
-      javascript_dialog_helper_(this) {
+      javascript_dialog_helper_(this),
+      auto_size_enabled_(false) {
 }
 
 WebViewGuest::~WebViewGuest() {
 }
 
 void WebViewGuest::DidCommitProvisionalLoadForFrame(
     content::RenderFrameHost* render_frame_host,
     const GURL& url,
     content::PageTransition transition_type) {
   find_helper_.CancelAllFindSessions();
@@ skipping 81 matching lines @@
   if (!entry)
     return;
   entry->SetIsOverridingUserAgent(!user_agent.empty());
   guest_web_contents()->GetController().Reload(false);
 }
 
 void WebViewGuest::RenderViewReady() {
   // The guest RenderView should always live in an isolated guest process.
   CHECK(guest_web_contents()->GetRenderProcessHost()->IsIsolatedGuest());
   Send(new ChromeViewMsg_SetName(guest_web_contents()->GetRoutingID(), name_));
+  content::RenderViewHost* rvh = guest_web_contents()->GetRenderViewHost();
+  if (auto_size_enabled_)
+    rvh->EnableAutoResize(min_auto_size_, max_auto_size_);
+  else
+    rvh->DisableAutoResize(element_size_);
+
 }
 
 void WebViewGuest::ReportFrameNameChange(const std::string& name) {
   name_ = name;
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetString(webview::kName, name);
   DispatchEventToEmbedder(
       new GuestViewBase::Event(webview::kEventFrameNameChanged, args.Pass()));
 }
 
@@ skipping 58 matching lines @@
     const content::WebContents::CreateParams& create_params) {
   GuestViewManager* guest_manager =
       GuestViewManager::FromBrowserContext(browser_context());
   return guest_manager->CreateGuestWithWebContentsParams(
       WebViewGuest::Type,
       embedder_extension_id(),
       embedder_web_contents()->GetRenderProcessHost()->GetID(),
       create_params);
 }
 
-void WebViewGuest::SizeChanged(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(
-      new GuestViewBase::Event(webview::kEventSizeChanged, args.Pass()));
+void WebViewGuest::GuestSizeChanged(const gfx::Size& old_size,
+                                    const gfx::Size& new_size) {
+  if (!auto_size_enabled_)
+    return;
+  DispatchSizeChangedEvent(old_size, new_size);
 }
 
 void WebViewGuest::RequestMediaAccessPermission(
     content::WebContents* source,
     const content::MediaStreamRequest& request,
     const content::MediaResponseCallback& callback) {
   web_view_permission_helper_->RequestMediaAccessPermission(source,
                                                             request,
                                                             callback);
 }
 
 void WebViewGuest::CanDownload(
     content::RenderViewHost* render_view_host,
     const GURL& url,
     const std::string& request_method,
     const base::Callback<void(bool)>& callback) {
   web_view_permission_helper_->CanDownload(render_view_host,
                                            url,
                                            request_method,
                                            callback);
 }
 
+void WebViewGuest::ElementSizeChanged(const gfx::Size& old_size,
+                                      const gfx::Size& new_size) {
+  element_size_ = new_size;
+}
+
 void WebViewGuest::RequestPointerLockPermission(
     bool user_gesture,
     bool last_unlocked_by_target,
     const base::Callback<void(bool)>& callback) {
   web_view_permission_helper_->RequestPointerLockPermission(
       user_gesture,
       last_unlocked_by_target,
       callback);
 }
 
@@ skipping 20 matching lines @@
 }
 
 void WebViewGuest::RunFileChooser(WebContents* web_contents,
                                   const content::FileChooserParams& params) {
   if (!attached() || !embedder_web_contents()->GetDelegate())
     return;
 
   embedder_web_contents()->GetDelegate()->RunFileChooser(web_contents, params);
 }
 
+void WebViewGuest::SetAutoSize(bool enabled,
+                               const gfx::Size& min_size,
+                               const gfx::Size& max_size) {
+  min_auto_size_ = gfx::Size(std::min(max_size.width(), min_size.width()),
+                             std::min(max_size.height(), min_size.height()));
+  max_auto_size_ = gfx::Size(std::max(max_size.width(), min_size.width()),
+                             std::max(max_size.height(), min_size.height()));
+  enabled &= !!max_auto_size_.width() && !!max_auto_size_.height();
+  if (!enabled && !auto_size_enabled_)
+    return;
+
+  auto_size_enabled_ = enabled;
+
+  if (!attached())
+    return;
+
+  content::RenderViewHost* rvh = guest_web_contents()->GetRenderViewHost();
+  if (auto_size_enabled_) {
+    rvh->EnableAutoResize(min_auto_size_, max_auto_size_);
+  } else {
+    rvh->DisableAutoResize(element_size_);
+    DispatchSizeChangedEvent(guest_size_, element_size_);
+  }
+}
+
 void WebViewGuest::NavigateGuest(const std::string& src) {
   GURL url = ResolveURL(src);
 
   // Do not allow navigating a guest to schemes other than known safe schemes.
   // This will block the embedder trying to load unwanted schemes, e.g.
   // chrome://settings.
   bool scheme_is_blocked =
       (!content::ChildProcessSecurityPolicy::GetInstance()->IsWebSafeScheme(
            url.scheme()) &&
        !url.SchemeIs(url::kAboutScheme)) ||
@@ skipping 81 matching lines @@
 
   if (event.windowsKeyCode == ui::VKEY_BROWSER_FORWARD) {
     Go(1);
     return true;
   }
 #endif
 
   return false;
 }
 
+void WebViewGuest::DispatchSizeChangedEvent(const gfx::Size& old_size,
+                                            const gfx::Size& new_size) {
+  guest_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(
+      new GuestViewBase::Event(webview::kEventSizeChanged, args.Pass()));
+}
+
 void WebViewGuest::ShowContextMenu(int request_id,
                                    const MenuItemVector* items) {
   if (!pending_menu_.get())
     return;
 
   // Make sure this was the correct request.
   if (request_id != pending_context_menu_request_id_)
     return;
 
   // TODO(lazyboy): Implement.
@@ skipping 174 matching lines @@
     bool allow,
     const std::string& user_input) {
   WebViewGuest* guest =
       WebViewGuest::From(embedder_render_process_id(), new_window_instance_id);
   if (!guest)
     return;
 
   if (!allow)
     guest->Destroy();
 }