<webview>: Move autosize from content to chrome

chrome/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 "chrome/browser/guest_view/guest_view_base.h"
 
 #include "base/lazy_instance.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/guest_view/app_view/app_view_guest.h"
 #include "chrome/browser/guest_view/extension_options/extension_options_guest.h"
@@ skipping 75 matching lines @@
 };
 
 GuestViewBase::GuestViewBase(content::BrowserContext* browser_context,
                              int guest_instance_id)
     : embedder_web_contents_(NULL),
       embedder_render_process_id_(0),
       browser_context_(browser_context),
       guest_instance_id_(guest_instance_id),
       view_instance_id_(guestview::kInstanceIDNone),
       initialized_(false),
+      auto_size_enabled_(false),
       weak_ptr_factory_(this) {
 }
 
 void GuestViewBase::Init(
     const std::string& embedder_extension_id,
     int embedder_render_process_id,
     const base::DictionaryValue& create_params,
     const WebContentsCreatedCallback& callback) {
   if (initialized_)
     return;
@@ skipping 30 matching lines @@
   guest_web_contents->SetDelegate(this);
   webcontents_guestview_map.Get().insert(
       std::make_pair(guest_web_contents, this));
   GuestViewManager::FromBrowserContext(browser_context_)->
       AddGuest(guest_instance_id_, guest_web_contents);
 
   // Give the derived class an opportunity to perform additional initialization.
   DidInitialize();
 }
 
+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())
+    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_);
+    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());
   guest_view_registry.Get()[view_type] = callback;
 }
 
@@ skipping 59 matching lines @@
                                   ContentSettingsPattern::Wildcard(),
                                   CONTENT_SETTING_ALLOW,
                                   std::string(),
                                   incognito));
 }
 
 base::WeakPtr<GuestViewBase> GuestViewBase::AsWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
+bool GuestViewBase::IsAutoSizeSupported() const {
+  return false;
+}
+
 bool GuestViewBase::IsDragAndDropEnabled() const {
   return false;
 }
 
 void GuestViewBase::RenderProcessExited(content::RenderProcessHost* host,
                                         base::ProcessHandle handle,
                                         base::TerminationStatus status,
                                         int exit_code) {
   // GuestViewBase tracks the lifetime of its embedder render process until it
   // is attached to a particular embedder WebContents. At that point, its
@@ skipping 26 matching lines @@
   delete guest_web_contents();
 }
 
 void GuestViewBase::DidAttach() {
   // Give the derived class an opportunity to perform some actions.
   DidAttachToEmbedder();
 
   SendQueuedEvents();
 }
 
+void GuestViewBase::ElementSizeChanged(const gfx::Size& old_size,
+                                       const gfx::Size& new_size) {
+  element_size_ = new_size;
+}
+
 int GuestViewBase::GetGuestInstanceID() const {
   return guest_instance_id_;
 }
 
+void GuestViewBase::GuestSizeChanged(const gfx::Size& old_size,
+                                     const gfx::Size& new_size) {
+  if (!auto_size_enabled_)
+    return;
+  guest_size_ = new_size;
+  GuestSizeChangedDueToAutoSize(old_size, new_size);
+}
+
 void GuestViewBase::SetOpener(GuestViewBase* guest) {
   if (guest && guest->IsViewType(GetViewType())) {
     opener_ = guest->AsWeakPtr();
     return;
   }
   opener_ = base::WeakPtr<GuestViewBase>();
 }
 
 void GuestViewBase::RegisterDestructionCallback(
     const DestructionCallback& callback) {
@@ skipping 19 matching lines @@
   if (!IsDragAndDropEnabled()) {
     const char script[] = "window.addEventListener('dragstart', function() { "
                           "  window.event.preventDefault(); "
                           "});";
     render_view_host->GetMainFrame()->ExecuteJavaScript(
         base::ASCIIToUTF16(script));
   }
   DidStopLoading();
 }
 
+void GuestViewBase::RenderViewReady() {
+  GuestReady();
+  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 GuestViewBase::WebContentsDestroyed() {
   GuestDestroyed();
   delete this;
 }
 
 bool GuestViewBase::ShouldFocusPageAfterCrash() {
   // Focus is managed elsewhere.
   return false;
 }
 
@@ skipping 60 matching lines @@
                       guest_web_contents);
   callback.Run(guest_web_contents);
 }
 
 // static
 void GuestViewBase::RegisterGuestViewTypes() {
   AppViewGuest::Register();
   ExtensionOptionsGuest::Register();
   WebViewGuest::Register();
 }