Reduce the public method footprint of GuestViewBase and derived types.

components/guest_view/browser/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 "components/guest_view/browser/guest_view_base.h"
 
 #include "base/lazy_instance.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/guest_view/browser/guest_view_event.h"
 #include "components/guest_view/browser/guest_view_manager.h"
@@ skipping 141 matching lines @@
       guest_host_(nullptr),
       auto_size_enabled_(false),
       is_full_page_plugin_(false),
       guest_proxy_routing_id_(MSG_ROUTING_NONE),
       weak_ptr_factory_(this) {
   owner_host_ = GuestViewManager::FromBrowserContext(browser_context_)->
       IsOwnedByExtension(this) ?
           owner_web_contents->GetLastCommittedURL().host() : std::string();
 }
 
+GuestViewBase::~GuestViewBase() {}
+
 void GuestViewBase::Init(const base::DictionaryValue& create_params,
                          const WebContentsCreatedCallback& callback) {
   if (initialized_)
     return;
   initialized_ = true;
 
   if (!GuestViewManager::FromBrowserContext(browser_context_)->
           IsGuestAvailableToContext(this)) {
     // The derived class did not create a WebContents so this class serves no
     // purpose. Let's self-destruct.
@@ skipping 47 matching lines @@
 
   // Observe guest zoom changes.
   auto zoom_controller =
       ui_zoom::ZoomController::FromWebContents(web_contents());
   zoom_controller->AddObserver(this);
 
   // Give the derived class an opportunity to perform additional initialization.
   DidInitialize(create_params);
 }
 
-void GuestViewBase::LoadURLWithParams(
-      const content::NavigationController::LoadURLParams& load_params) {
-  int guest_proxy_routing_id = host()->LoadURLWithParams(load_params);
-  DCHECK(guest_proxy_routing_id_ == MSG_ROUTING_NONE ||
-         guest_proxy_routing_id == guest_proxy_routing_id_);
-  guest_proxy_routing_id_ = guest_proxy_routing_id;
-}
-
-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(kOldWidth, old_size.width());
-  args->SetInteger(kOldHeight, old_size.height());
-  args->SetInteger(kNewWidth, new_size.width());
-  args->SetInteger(kNewHeight, new_size.height());
-  DispatchEventToGuestProxy(new GuestViewEvent(kEventResize, args.Pass()));
-}
-
-gfx::Size GuestViewBase::GetDefaultSize() const {
-  if (is_full_page_plugin()) {
-    // Full page plugins default to the size of the owner's viewport.
-    return owner_web_contents()
-        ->GetRenderWidgetHostView()
-        ->GetVisibleViewportSize();
-  } else {
-    return gfx::Size(kDefaultWidth, kDefaultHeight);
-  }
-}
-
-void GuestViewBase::SetSize(const SetSizeParams& params) {
-  bool enable_auto_size =
-      params.enable_auto_size ? *params.enable_auto_size : auto_size_enabled_;
-  gfx::Size min_size = params.min_size ? *params.min_size : min_auto_size_;
-  gfx::Size max_size = params.max_size ? *params.max_size : max_auto_size_;
-
-  if (params.normal_size)
-    normal_size_ = *params.normal_size;
-
-  min_auto_size_ = min_size;
-  min_auto_size_.SetToMin(max_size);
-  max_auto_size_ = max_size;
-  max_auto_size_.SetToMax(min_size);
-
-  enable_auto_size &= !min_auto_size_.IsEmpty() && !max_auto_size_.IsEmpty() &&
-                      IsAutoSizeSupported();
-
-  content::RenderViewHost* rvh = web_contents()->GetRenderViewHost();
-  if (enable_auto_size) {
-    // Autosize is being enabled.
-    rvh->EnableAutoResize(min_auto_size_, max_auto_size_);
-    normal_size_.SetSize(0, 0);
-  } else {
-    // Autosize is being disabled.
-    // Use default width/height if missing from partially defined normal size.
-    if (normal_size_.width() && !normal_size_.height())
-      normal_size_.set_height(GetDefaultSize().height());
-    if (!normal_size_.width() && normal_size_.height())
-      normal_size_.set_width(GetDefaultSize().width());
-
-    gfx::Size new_size;
-    if (!normal_size_.IsEmpty()) {
-      new_size = normal_size_;
-    } else if (!guest_size_.IsEmpty()) {
-      new_size = guest_size_;
-    } else {
-      new_size = GetDefaultSize();
-    }
-
-    bool changed_due_to_auto_resize = false;
-    if (auto_size_enabled_) {
-      // Autosize was previously enabled.
-      rvh->DisableAutoResize(new_size);
-      changed_due_to_auto_resize = true;
-    } else {
-      // Autosize was already disabled.
-      guest_host_->SizeContents(new_size);
-    }
-
-    UpdateGuestSize(new_size, changed_due_to_auto_resize);
-  }
-
-  auto_size_enabled_ = enable_auto_size;
-}
-
 // static
 void GuestViewBase::CleanUp(content::BrowserContext* browser_context,
                             int embedder_process_id,
                             int view_instance_id) {
   // TODO(paulmeyer): Add in any general GuestView cleanup work here.
 }
 
 // static
 GuestViewBase* GuestViewBase::FromWebContents(const WebContents* web_contents) {
   WebContentsGuestViewMap* guest_map = webcontents_guestview_map.Pointer();
@@ skipping 22 matching lines @@
   while (GuestViewBase* guest = FromWebContents(web_contents))
     web_contents = guest->owner_web_contents();
   return web_contents;
 }
 
 // static
 bool GuestViewBase::IsGuest(WebContents* web_contents) {
   return !!GuestViewBase::FromWebContents(web_contents);
 }
 
-bool GuestViewBase::IsAutoSizeSupported() const {
-  return false;
-}
-
-bool GuestViewBase::IsPreferredSizeModeEnabled() const {
-  return false;
-}
-
-bool GuestViewBase::ZoomPropagatesFromEmbedderToGuest() const {
-  return true;
-}
-
-void GuestViewBase::SetContextMenuPosition(const gfx::Point& position) {}
-
-WebContents* GuestViewBase::CreateNewGuestWindow(
-    const WebContents::CreateParams& create_params) {
-  auto guest_manager = GuestViewManager::FromBrowserContext(browser_context());
-  return guest_manager->CreateGuestWithWebContentsParams(
-      GetViewType(),
-      owner_web_contents(),
-      create_params);
-}
-
 void GuestViewBase::DidAttach(int guest_proxy_routing_id) {
   DCHECK(guest_proxy_routing_id_ == MSG_ROUTING_NONE ||
          guest_proxy_routing_id == guest_proxy_routing_id_);
   guest_proxy_routing_id_ = guest_proxy_routing_id;
 
   opener_lifetime_observer_.reset();
 
   SetUpSizing(*attach_params());
 
   // Give the derived class an opportunity to perform some actions.
   DidAttachToEmbedder();
 
   // Inform the associated GuestViewContainer that the contentWindow is ready.
   embedder_web_contents()->Send(new GuestViewMsg_GuestAttached(
       element_instance_id_,
       guest_proxy_routing_id));
 
   SendQueuedEvents();
 }
 
-void GuestViewBase::DidDetach() {
-  GuestViewManager::FromBrowserContext(browser_context_)->DetachGuest(this);
-  StopTrackingEmbedderZoomLevel();
-  owner_web_contents()->Send(new GuestViewMsg_GuestDetached(
-      element_instance_id_));
-  element_instance_id_ = kInstanceIDNone;
+void GuestViewBase::WillAttach(WebContents* embedder_web_contents,
+                               int element_instance_id,
+                               bool is_full_page_plugin,
+                               const base::Closure& callback) {
+  // Stop tracking the old embedder's zoom level.
+  if (owner_web_contents())
+    StopTrackingEmbedderZoomLevel();
+
+  if (owner_web_contents_ != embedder_web_contents) {
+    DCHECK_EQ(owner_contents_observer_->web_contents(), owner_web_contents_);
+    owner_web_contents_ = embedder_web_contents;
+    owner_contents_observer_.reset(
+        new OwnerContentsObserver(this, embedder_web_contents));
+    owner_host_ = GuestViewManager::FromBrowserContext(browser_context_)
+                          ->IsOwnedByExtension(this)
+                      ? owner_web_contents()->GetLastCommittedURL().host()
+                      : std::string();
+  }
+
+  // Start tracking the new embedder's zoom level.
+  StartTrackingEmbedderZoomLevel();
+  element_instance_id_ = element_instance_id;
+  is_full_page_plugin_ = is_full_page_plugin;
+
+  WillAttachToEmbedder();
+
+  // Completing attachment will resume suspended resource loads and then send
+  // queued events.
+  SignalWhenReady(callback);
 }
 
-bool GuestViewBase::Find(int request_id,
-                         const base::string16& search_text,
-                         const blink::WebFindOptions& options) {
-  if (ShouldHandleFindRequestsForEmbedder()) {
-    web_contents()->Find(request_id, search_text, options);
-    return true;
-  }
+bool GuestViewBase::IsAutoSizeSupported() const {
   return false;
 }
 
-bool GuestViewBase::StopFinding(content::StopFindAction action) {
-  if (ShouldHandleFindRequestsForEmbedder()) {
-    web_contents()->StopFinding(action);
-    return true;
-  }
+bool GuestViewBase::IsPreferredSizeModeEnabled() const {
   return false;
 }
 
-WebContents* GuestViewBase::GetOwnerWebContents() const {
-  return owner_web_contents_;
+bool GuestViewBase::ZoomPropagatesFromEmbedderToGuest() const {
+  return true;
 }
 
-void GuestViewBase::GuestSizeChanged(const gfx::Size& new_size) {
-  UpdateGuestSize(new_size, auto_size_enabled_);
+void GuestViewBase::DispatchEventToGuestProxy(GuestViewEvent* event) {
+  event->Dispatch(this, guest_instance_id_);
+}
+
+void GuestViewBase::DispatchEventToView(GuestViewEvent* event) {
+  if (!attached() &&
+      (!CanRunInDetachedState() || !can_owner_receive_events())) {
+    pending_events_.push_back(linked_ptr<GuestViewEvent>(event));
+    return;
+  }
+
+  event->Dispatch(this, view_instance_id_);
+}
+
+void GuestViewBase::SetSize(const SetSizeParams& params) {
+  bool enable_auto_size =
+      params.enable_auto_size ? *params.enable_auto_size : auto_size_enabled_;
+  gfx::Size min_size = params.min_size ? *params.min_size : min_auto_size_;
+  gfx::Size max_size = params.max_size ? *params.max_size : max_auto_size_;
+
+  if (params.normal_size)
+    normal_size_ = *params.normal_size;
+
+  min_auto_size_ = min_size;
+  min_auto_size_.SetToMin(max_size);
+  max_auto_size_ = max_size;
+  max_auto_size_.SetToMax(min_size);
+
+  enable_auto_size &= !min_auto_size_.IsEmpty() && !max_auto_size_.IsEmpty() &&
+                      IsAutoSizeSupported();
+
+  content::RenderViewHost* rvh = web_contents()->GetRenderViewHost();
+  if (enable_auto_size) {
+    // Autosize is being enabled.
+    rvh->EnableAutoResize(min_auto_size_, max_auto_size_);
+    normal_size_.SetSize(0, 0);
+  } else {
+    // Autosize is being disabled.
+    // Use default width/height if missing from partially defined normal size.
+    if (normal_size_.width() && !normal_size_.height())
+      normal_size_.set_height(GetDefaultSize().height());
+    if (!normal_size_.width() && normal_size_.height())
+      normal_size_.set_width(GetDefaultSize().width());
+
+    gfx::Size new_size;
+    if (!normal_size_.IsEmpty()) {
+      new_size = normal_size_;
+    } else if (!guest_size_.IsEmpty()) {
+      new_size = guest_size_;
+    } else {
+      new_size = GetDefaultSize();
+    }
+
+    bool changed_due_to_auto_resize = false;
+    if (auto_size_enabled_) {
+      // Autosize was previously enabled.
+      rvh->DisableAutoResize(new_size);
+      changed_due_to_auto_resize = true;
+    } else {
+      // Autosize was already disabled.
+      guest_host_->SizeContents(new_size);
+    }
+
+    UpdateGuestSize(new_size, changed_due_to_auto_resize);
+  }
+
+  auto_size_enabled_ = enable_auto_size;
 }
 
 const GURL& GuestViewBase::GetOwnerSiteURL() const {
   return owner_web_contents()->GetLastCommittedURL();
 }
 
 void GuestViewBase::Destroy() {
   if (is_being_destroyed_)
     return;
 
@@ skipping 36 matching lines @@
   if (guest && guest->IsViewType(GetViewType())) {
     opener_ = guest->weak_ptr_factory_.GetWeakPtr();
     if (!attached())
       opener_lifetime_observer_.reset(new OpenerLifetimeObserver(this));
     return;
   }
   opener_ = base::WeakPtr<GuestViewBase>();
   opener_lifetime_observer_.reset();
 }
 
-void GuestViewBase::SetGuestHost(content::GuestHost* guest_host) {
-  guest_host_ = guest_host;
+void GuestViewBase::SetContextMenuPosition(const gfx::Point& position) {}
+
+void GuestViewBase::HandleKeyboardEvent(
+    WebContents* source,
+    const content::NativeWebKeyboardEvent& event) {
+  if (!attached())
+    return;
+
+  // Send the keyboard events back to the embedder to reprocess them.
+  embedder_web_contents()->GetDelegate()->HandleKeyboardEvent(
+      embedder_web_contents(), event);
 }
 
-void GuestViewBase::WillAttach(WebContents* embedder_web_contents,
-                               int element_instance_id,
-                               bool is_full_page_plugin,
-                               const base::Closure& callback) {
-  // Stop tracking the old embedder's zoom level.
-  if (owner_web_contents())
-    StopTrackingEmbedderZoomLevel();
+bool GuestViewBase::PreHandleGestureEvent(WebContents* source,
+                                          const blink::WebGestureEvent& event) {
+  return event.type == blink::WebGestureEvent::GesturePinchBegin ||
+         event.type == blink::WebGestureEvent::GesturePinchUpdate ||
+         event.type == blink::WebGestureEvent::GesturePinchEnd;
+}
 
-  if (owner_web_contents_ != embedder_web_contents) {
-    DCHECK_EQ(owner_contents_observer_->web_contents(), owner_web_contents_);
-    owner_web_contents_ = embedder_web_contents;
-    owner_contents_observer_.reset(
-        new OwnerContentsObserver(this, embedder_web_contents));
-    owner_host_ = GuestViewManager::FromBrowserContext(browser_context_)->
-        IsOwnedByExtension(this) ?
-            owner_web_contents()->GetLastCommittedURL().host() : std::string();
+void GuestViewBase::FindReply(WebContents* source,
+                              int request_id,
+                              int number_of_matches,
+                              const gfx::Rect& selection_rect,
+                              int active_match_ordinal,
+                              bool final_update) {
+  if (ShouldHandleFindRequestsForEmbedder() && attached() &&
+      embedder_web_contents()->GetDelegate()) {
+    embedder_web_contents()->GetDelegate()->FindReply(
+        embedder_web_contents(), request_id, number_of_matches, selection_rect,
+        active_match_ordinal, final_update);
   }
+}
 
-  // Start tracking the new embedder's zoom level.
-  StartTrackingEmbedderZoomLevel();
-  element_instance_id_ = element_instance_id;
-  is_full_page_plugin_ = is_full_page_plugin;
+void GuestViewBase::DidNavigateMainFrame(
+    const content::LoadCommittedDetails& details,
+    const content::FrameNavigateParams& params) {
+  if (attached() && ZoomPropagatesFromEmbedderToGuest())
+    SetGuestZoomLevelToMatchEmbedder();
 
-  WillAttachToEmbedder();
-
-  // Completing attachment will resume suspended resource loads and then send
-  // queued events.
-  SignalWhenReady(callback);
+  // TODO(lazyboy): This breaks guest visibility in --site-per-process because
+  // we do not take the widget's visibility into account.  We need to also
+  // stay hidden during "visibility:none" state.
+  if (content::BrowserPluginGuestMode::UseCrossProcessFramesForGuests()) {
+    web_contents()->WasShown();
+  }
 }
 
 void GuestViewBase::SignalWhenReady(const base::Closure& callback) {
   // The default behavior is to call the |callback| immediately. Derived classes
   // can implement an alternative signal for readiness.
   callback.Run();
 }
 
 bool GuestViewBase::ShouldHandleFindRequestsForEmbedder() const {
   return false;
 }
 
+void GuestViewBase::LoadURLWithParams(
+    const content::NavigationController::LoadURLParams& load_params) {
+  int guest_proxy_routing_id = host()->LoadURLWithParams(load_params);
+  DCHECK(guest_proxy_routing_id_ == MSG_ROUTING_NONE ||
+         guest_proxy_routing_id == guest_proxy_routing_id_);
+  guest_proxy_routing_id_ = guest_proxy_routing_id;
+}
+
 int GuestViewBase::LogicalPixelsToPhysicalPixels(double logical_pixels) const {
   DCHECK(logical_pixels >= 0);
   double zoom_factor = GetEmbedderZoomFactor();
   return lround(logical_pixels * zoom_factor);
 }
 
 double GuestViewBase::PhysicalPixelsToLogicalPixels(int physical_pixels) const {
   DCHECK(physical_pixels >= 0);
   double zoom_factor = GetEmbedderZoomFactor();
   return physical_pixels / zoom_factor;
 }
 
-void GuestViewBase::DidStopLoading() {
-  content::RenderViewHost* rvh = web_contents()->GetRenderViewHost();
+void GuestViewBase::SetGuestZoomLevelToMatchEmbedder() {
+  auto embedder_zoom_controller =
+      ui_zoom::ZoomController::FromWebContents(owner_web_contents());
+  if (!embedder_zoom_controller)
+    return;
 
-  if (IsPreferredSizeModeEnabled())
-    rvh->EnablePreferredSizeMode();
-  GuestViewDidStopLoading();
+  ui_zoom::ZoomController::FromWebContents(web_contents())
+      ->SetZoomLevel(embedder_zoom_controller->GetZoomLevel());
 }
 
-void GuestViewBase::RenderViewReady() {
-  GuestReady();
+WebContents* GuestViewBase::CreateNewGuestWindow(
+    const WebContents::CreateParams& create_params) {
+  auto guest_manager = GuestViewManager::FromBrowserContext(browser_context());
+  return guest_manager->CreateGuestWithWebContentsParams(
+      GetViewType(), owner_web_contents(), create_params);
 }
 
-void GuestViewBase::WebContentsDestroyed() {
-  // Let the derived class know that its WebContents is in the process of
-  // being destroyed. web_contents() is still valid at this point.
-  // TODO(fsamuel): This allows for reentrant code into WebContents during
-  // destruction. This could potentially lead to bugs. Perhaps we should get rid
-  // of this?
-  GuestDestroyed();
-
-  // Self-destruct.
-  delete this;
+void GuestViewBase::DidDetach() {
+  GuestViewManager::FromBrowserContext(browser_context_)->DetachGuest(this);
+  StopTrackingEmbedderZoomLevel();
+  owner_web_contents()->Send(
+      new GuestViewMsg_GuestDetached(element_instance_id_));
+  element_instance_id_ = kInstanceIDNone;
 }
 
-void GuestViewBase::DidNavigateMainFrame(
-    const content::LoadCommittedDetails& details,
-    const content::FrameNavigateParams& params) {
-  if (attached() && ZoomPropagatesFromEmbedderToGuest())
-    SetGuestZoomLevelToMatchEmbedder();
+bool GuestViewBase::Find(int request_id,
+                         const base::string16& search_text,
+                         const blink::WebFindOptions& options) {
+  if (ShouldHandleFindRequestsForEmbedder()) {
+    web_contents()->Find(request_id, search_text, options);
+    return true;
+  }
+  return false;
+}
 
-  // TODO(lazyboy): This breaks guest visibility in --site-per-process because
-  // we do not take the widget's visibility into account.  We need to also
-  // stay hidden during "visibility:none" state.
-  if (content::BrowserPluginGuestMode::UseCrossProcessFramesForGuests()) {
-    web_contents()->WasShown();
+bool GuestViewBase::StopFinding(content::StopFindAction action) {
+  if (ShouldHandleFindRequestsForEmbedder()) {
+    web_contents()->StopFinding(action);
+    return true;
   }
+  return false;
+}
+
+WebContents* GuestViewBase::GetOwnerWebContents() const {
+  return owner_web_contents_;
+}
+
+void GuestViewBase::GuestSizeChanged(const gfx::Size& new_size) {
+  UpdateGuestSize(new_size, auto_size_enabled_);
+}
+
+void GuestViewBase::SetGuestHost(content::GuestHost* guest_host) {
+  guest_host_ = guest_host;
 }
 
 void GuestViewBase::ActivateContents(WebContents* web_contents) {
   if (!attached() || !embedder_web_contents()->GetDelegate())
     return;
 
   embedder_web_contents()->GetDelegate()->ActivateContents(
       embedder_web_contents());
 }
 
@@ skipping 14 matching lines @@
   embedder_web_contents()->GetDelegate()->ContentsMouseEvent(
       embedder_web_contents(), location, motion);
 }
 
 void GuestViewBase::ContentsZoomChange(bool zoom_in) {
   ui_zoom::PageZoom::Zoom(
       embedder_web_contents(),
       zoom_in ? content::PAGE_ZOOM_IN : content::PAGE_ZOOM_OUT);
 }
 
-void GuestViewBase::HandleKeyboardEvent(
-    WebContents* source,
-    const content::NativeWebKeyboardEvent& event) {
-  if (!attached())
-    return;
-
-  // Send the keyboard events back to the embedder to reprocess them.
-  embedder_web_contents()->GetDelegate()->
-      HandleKeyboardEvent(embedder_web_contents(), event);
-}
-
 void GuestViewBase::LoadingStateChanged(WebContents* source,
                                         bool to_different_document) {
   if (!attached() || !embedder_web_contents()->GetDelegate())
     return;
 
   embedder_web_contents()->GetDelegate()->LoadingStateChanged(
       embedder_web_contents(), to_different_document);
 }
 
 content::ColorChooser* GuestViewBase::OpenColorChooser(
@@ skipping 18 matching lines @@
     return;
 
   embedder_web_contents()->GetDelegate()->RunFileChooser(web_contents, params);
 }
 
 bool GuestViewBase::ShouldFocusPageAfterCrash() {
   // Focus is managed elsewhere.
   return false;
 }
 
-bool GuestViewBase::PreHandleGestureEvent(WebContents* source,
-                                          const blink::WebGestureEvent& event) {
-  return event.type == blink::WebGestureEvent::GesturePinchBegin ||
-      event.type == blink::WebGestureEvent::GesturePinchUpdate ||
-      event.type == blink::WebGestureEvent::GesturePinchEnd;
-}
-
 void GuestViewBase::UpdatePreferredSize(WebContents* target_web_contents,
                                         const gfx::Size& pref_size) {
   // In theory it's not necessary to check IsPreferredSizeModeEnabled() because
   // there will only be events if it was enabled in the first place. However,
   // something else may have turned on preferred size mode, so double check.
   DCHECK_EQ(web_contents(), target_web_contents);
   if (IsPreferredSizeModeEnabled()) {
     OnPreferredSizeChanged(pref_size);
   }
 }
 
 void GuestViewBase::UpdateTargetURL(WebContents* source, const GURL& url) {
   if (!attached() || !embedder_web_contents()->GetDelegate())
     return;
 
   embedder_web_contents()->GetDelegate()->UpdateTargetURL(
       embedder_web_contents(), url);
 }
 
 bool GuestViewBase::ShouldResumeRequestsForCreatedWindow() {
   return false;
 }
 
-void GuestViewBase::FindReply(WebContents* source,
-                              int request_id,
-                              int number_of_matches,
-                              const gfx::Rect& selection_rect,
-                              int active_match_ordinal,
-                              bool final_update) {
-  if (ShouldHandleFindRequestsForEmbedder() &&
-      attached() && embedder_web_contents()->GetDelegate()) {
-    embedder_web_contents()->GetDelegate()->FindReply(embedder_web_contents(),
-                                                      request_id,
-                                                      number_of_matches,
-                                                      selection_rect,
-                                                      active_match_ordinal,
-                                                      final_update);
-  }
+void GuestViewBase::DidStopLoading() {
+  content::RenderViewHost* rvh = web_contents()->GetRenderViewHost();
+
+  if (IsPreferredSizeModeEnabled())
+    rvh->EnablePreferredSizeMode();
+  GuestViewDidStopLoading();
 }
 
-GuestViewBase::~GuestViewBase() {
+void GuestViewBase::RenderViewReady() {
+  GuestReady();
+}
+
+void GuestViewBase::WebContentsDestroyed() {
+  // Let the derived class know that its WebContents is in the process of
+  // being destroyed. web_contents() is still valid at this point.
+  // TODO(fsamuel): This allows for reentrant code into WebContents during
+  // destruction. This could potentially lead to bugs. Perhaps we should get rid
+  // of this?
+  GuestDestroyed();
+
+  // Self-destruct.
+  delete this;
 }
 
 void GuestViewBase::OnZoomChanged(
     const ui_zoom::ZoomController::ZoomChangedEventData& data) {
   if (data.web_contents == embedder_web_contents()) {
     // The embedder's zoom level has changed.
     auto guest_zoom_controller =
         ui_zoom::ZoomController::FromWebContents(web_contents());
     if (content::ZoomValuesEqual(data.new_zoom_level,
                                  guest_zoom_controller->GetZoomLevel())) {
       return;
     }
     // When the embedder's zoom level doesn't match the guest's, then update the
     // guest's zoom level to match.
     guest_zoom_controller->SetZoomLevel(data.new_zoom_level);
-
-    EmbedderZoomChanged(data.old_zoom_level, data.new_zoom_level);

[Fady Samuel, 2015/10/10 10:58:01]

Why was this deleted?

[paulmeyer, 2015/10/16 21:13:03]

Because it does nothing and is never overridden.

[Fady Samuel, 2015/10/16 21:17:28]

Acknowledged.

     return;
   }
 
   if (data.web_contents == web_contents()) {
     // The guest's zoom level has changed.
     GuestZoomChanged(data.old_zoom_level, data.new_zoom_level);
   }
 }
 
-void GuestViewBase::DispatchEventToGuestProxy(GuestViewEvent* event) {
-  event->Dispatch(this, guest_instance_id_);
-}
-
-void GuestViewBase::DispatchEventToView(GuestViewEvent* event) {
-  if (!attached() &&
-      (!CanRunInDetachedState() || !can_owner_receive_events())) {
-    pending_events_.push_back(linked_ptr<GuestViewEvent>(event));
-    return;
-  }
-
-  event->Dispatch(this, view_instance_id_);
-}
-
 void GuestViewBase::SendQueuedEvents() {
   if (!attached())
     return;
   while (!pending_events_.empty()) {
     linked_ptr<GuestViewEvent> event_ptr = pending_events_.front();
     pending_events_.pop_front();
     event_ptr.release()->Dispatch(this, view_instance_id_);
   }
 }
 
 void GuestViewBase::CompleteInit(
     scoped_ptr<base::DictionaryValue> create_params,
     const WebContentsCreatedCallback& callback,
     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.
     delete this;
     callback.Run(nullptr);
     return;
   }
   InitWithWebContents(*create_params, guest_web_contents);
   callback.Run(guest_web_contents);
 }
 
+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(kOldWidth, old_size.width());
+  args->SetInteger(kOldHeight, old_size.height());
+  args->SetInteger(kNewWidth, new_size.width());
+  args->SetInteger(kNewHeight, new_size.height());
+  DispatchEventToGuestProxy(new GuestViewEvent(kEventResize, args.Pass()));
+}
+
+gfx::Size GuestViewBase::GetDefaultSize() const {
+  if (is_full_page_plugin()) {
+    // Full page plugins default to the size of the owner's viewport.
+    return owner_web_contents()
+        ->GetRenderWidgetHostView()
+        ->GetVisibleViewportSize();
+  } else {
+    return gfx::Size(kDefaultWidth, kDefaultHeight);
+  }
+}
+
 double GuestViewBase::GetEmbedderZoomFactor() const {
   if (!embedder_web_contents())
     return 1.0;
 
   return content::ZoomLevelToZoomFactor(
       ui_zoom::ZoomController::GetZoomLevelForWebContents(
           embedder_web_contents()));
 }
 
 void GuestViewBase::SetUpSizing(const base::DictionaryValue& params) {
@@ skipping 37 matching lines @@
   set_size_params.enable_auto_size.reset(new bool(auto_size_enabled));
   set_size_params.min_size.reset(new gfx::Size(min_width, min_height));
   set_size_params.max_size.reset(new gfx::Size(max_width, max_height));
   set_size_params.normal_size.reset(new gfx::Size(normal_width, normal_height));
 
   // Call SetSize to apply all the appropriate validation and clipping of
   // values.
   SetSize(set_size_params);
 }
 
-void GuestViewBase::SetGuestZoomLevelToMatchEmbedder() {
-  auto embedder_zoom_controller =
-      ui_zoom::ZoomController::FromWebContents(owner_web_contents());
-  if (!embedder_zoom_controller)
-    return;
-
-  ui_zoom::ZoomController::FromWebContents(web_contents())
-      ->SetZoomLevel(embedder_zoom_controller->GetZoomLevel());
-}
-
 void GuestViewBase::StartTrackingEmbedderZoomLevel() {
   if (!ZoomPropagatesFromEmbedderToGuest())
     return;
 
   auto embedder_zoom_controller =
       ui_zoom::ZoomController::FromWebContents(owner_web_contents());
   // Chrome Apps do not have a ZoomController.
   if (!embedder_zoom_controller)
     return;
   // Listen to the embedder's zoom changes.
@@ skipping 17 matching lines @@
 
 void GuestViewBase::UpdateGuestSize(const gfx::Size& new_size,
                                     bool due_to_auto_resize) {
   if (due_to_auto_resize)
     GuestSizeChangedDueToAutoSize(guest_size_, new_size);
   DispatchOnResizeEvent(guest_size_, new_size);
   guest_size_ = new_size;
 }
 
 }  // namespace guest_view