components/guest_view/browser/guest_view_base.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "components/guest_view/browser/guest_view_base.h"
   6
   7 #include "base/lazy_instance.h"
   8 #include "base/strings/utf_string_conversions.h"
   9 #include "components/guest_view/browser/guest_view_event.h"
  10 #include "components/guest_view/browser/guest_view_manager.h"
  11 #include "components/guest_view/common/guest_view_constants.h"
  12 #include "components/guest_view/common/guest_view_messages.h"
  13 #include "components/ui/zoom/page_zoom.h"
  14 #include "components/ui/zoom/zoom_controller.h"
  15 #include "content/public/browser/navigation_details.h"
  16 #include "content/public/browser/render_frame_host.h"
  17 #include "content/public/browser/render_process_host.h"
  18 #include "content/public/browser/render_view_host.h"
  19 #include "content/public/browser/render_widget_host_view.h"
  20 #include "content/public/browser/web_contents.h"
  21 #include "content/public/common/browser_plugin_guest_mode.h"
  22 #include "content/public/common/page_zoom.h"
  23 #include "content/public/common/url_constants.h"
  24 #include "third_party/WebKit/public/web/WebInputEvent.h"
  25
  26 using content::WebContents;
  27
  28 namespace content {
  29 struct FrameNavigateParams;
  30 }
  31
  32 namespace guest_view {
  33
  34 namespace {
  35
  36 using WebContentsGuestViewMap = std::map<const WebContents*, GuestViewBase*>;
  37 static base::LazyInstance<WebContentsGuestViewMap> webcontents_guestview_map =
  38     LAZY_INSTANCE_INITIALIZER;
  39
  40 }  // namespace
  41
  42 SetSizeParams::SetSizeParams() {
  43 }
  44 SetSizeParams::~SetSizeParams() {
  45 }
  46
  47 // This observer ensures that the GuestViewBase destroys itself when its
  48 // embedder goes away. It also tracks when the embedder's fullscreen is
  49 // toggled so the guest can change itself accordingly.
  50 class GuestViewBase::OwnerContentsObserver : public WebContentsObserver {
  51  public:
  52   OwnerContentsObserver(GuestViewBase* guest,
  53                         WebContents* embedder_web_contents)
  54       : WebContentsObserver(embedder_web_contents),
  55         is_fullscreen_(false),
  56         destroyed_(false),
  57         guest_(guest) {}
  58
  59   ~OwnerContentsObserver() override {}
  60
  61   // WebContentsObserver implementation.
  62   void WebContentsDestroyed() override {
  63     // If the embedder is destroyed then destroy the guest.
  64     Destroy();
  65   }
  66
  67   void DidNavigateMainFrame(
  68       const content::LoadCommittedDetails& details,
  69       const content::FrameNavigateParams& params) override {
  70     // If the embedder navigates to a different page then destroy the guest.
  71     if (details.is_navigation_to_different_page())
  72       Destroy();
  73   }
  74
  75   void RenderProcessGone(base::TerminationStatus status) override {
  76     if (destroyed_)
  77       return;
  78     // If the embedder process is destroyed, then destroy the guest.
  79     Destroy();
  80   }
  81
  82   void DidToggleFullscreenModeForTab(bool entered_fullscreen) override {
  83     if (destroyed_)
  84       return;
  85
  86     is_fullscreen_ = entered_fullscreen;
  87     guest_->EmbedderFullscreenToggled(is_fullscreen_);
  88   }
  89
  90   void MainFrameWasResized(bool width_changed) override {
  91     if (destroyed_ || !web_contents()->GetDelegate())
  92       return;
  93
  94     bool current_fullscreen =
  95         web_contents()->GetDelegate()->IsFullscreenForTabOrPending(
  96             web_contents());
  97     if (is_fullscreen_ && !current_fullscreen) {
  98       is_fullscreen_ = false;
  99       guest_->EmbedderFullscreenToggled(is_fullscreen_);
 100     }
 101   }
 102
 103  private:
 104   bool is_fullscreen_;
 105   bool destroyed_;
 106   GuestViewBase* guest_;
 107
 108   void Destroy() {
 109     if (destroyed_)
 110       return;
 111     destroyed_ = true;
 112     guest_->Destroy();
 113   }
 114
 115   DISALLOW_COPY_AND_ASSIGN(OwnerContentsObserver);
 116 };
 117
 118 // This observer ensures that the GuestViewBase destroys itself if its opener
 119 // WebContents goes away before the GuestViewBase is attached.
 120 class GuestViewBase::OpenerLifetimeObserver : public WebContentsObserver {
 121  public:
 122   OpenerLifetimeObserver(GuestViewBase* guest)
 123       : WebContentsObserver(guest->GetOpener()->web_contents()),
 124         guest_(guest) {}
 125
 126   ~OpenerLifetimeObserver() override {}
 127
 128   // WebContentsObserver implementation.
 129   void WebContentsDestroyed() override {
 130     if (guest_->attached())
 131       return;
 132
 133     // If the opener is destroyed then destroy the guest.
 134     guest_->Destroy();
 135   }
 136
 137  private:
 138   GuestViewBase* guest_;
 139
 140   DISALLOW_COPY_AND_ASSIGN(OpenerLifetimeObserver);
 141 };
 142
 143 GuestViewBase::GuestViewBase(WebContents* owner_web_contents)
 144     : owner_web_contents_(owner_web_contents),
 145       browser_context_(owner_web_contents->GetBrowserContext()),
 146       guest_instance_id_(GuestViewManager::FromBrowserContext(browser_context_)
 147                              ->GetNextInstanceID()),
 148       view_instance_id_(kInstanceIDNone),
 149       element_instance_id_(kInstanceIDNone),
 150       initialized_(false),
 151       is_being_destroyed_(false),
 152       guest_host_(nullptr),
 153       auto_size_enabled_(false),
 154       is_full_page_plugin_(false),
 155       guest_proxy_routing_id_(MSG_ROUTING_NONE),
 156       weak_ptr_factory_(this) {
 157   owner_host_ = GuestViewManager::FromBrowserContext(browser_context_)->
 158       IsOwnedByExtension(this) ?
 159           owner_web_contents->GetLastCommittedURL().host() : std::string();
 160 }
 161
 162 void GuestViewBase::Init(const base::DictionaryValue& create_params,
 163                          const WebContentsCreatedCallback& callback) {
 164   if (initialized_)
 165     return;
 166   initialized_ = true;
 167
 168   if (!GuestViewManager::FromBrowserContext(browser_context_)->
 169           IsGuestAvailableToContext(this)) {
 170     // The derived class did not create a WebContents so this class serves no
 171     // purpose. Let's self-destruct.
 172     delete this;
 173     callback.Run(nullptr);
 174     return;
 175   }
 176
 177   scoped_ptr<base::DictionaryValue> params(create_params.DeepCopy());
 178   CreateWebContents(create_params,
 179                     base::Bind(&GuestViewBase::CompleteInit,
 180                                weak_ptr_factory_.GetWeakPtr(),
 181                                base::Passed(&params),
 182                                callback));
 183 }
 184
 185 void GuestViewBase::InitWithWebContents(
 186     const base::DictionaryValue& create_params,
 187     WebContents* guest_web_contents) {
 188   DCHECK(guest_web_contents);
 189
 190   // Create a ZoomController to allow the guest's contents to be zoomed.
 191   // Do this before adding the GuestView as a WebContents Observer so that
 192   // the GuestView and its derived classes can re-configure the ZoomController
 193   // after the latter has handled WebContentsObserver events (observers are
 194   // notified of events in the same order they are added as observers). For
 195   // example, GuestViewBase may wish to put its guest into isolated zoom mode
 196   // in DidNavigateMainFrame, but since ZoomController always resets to default
 197   // zoom mode on this event, GuestViewBase would need to do so after
 198   // ZoomController::DidNavigateMainFrame has completed.
 199   ui_zoom::ZoomController::CreateForWebContents(guest_web_contents);
 200
 201   // At this point, we have just created the guest WebContents, we need to add
 202   // an observer to the owner WebContents. This observer will be responsible
 203   // for destroying the guest WebContents if the owner goes away.
 204   owner_contents_observer_.reset(
 205       new OwnerContentsObserver(this, owner_web_contents_));
 206
 207   WebContentsObserver::Observe(guest_web_contents);
 208   guest_web_contents->SetDelegate(this);
 209   webcontents_guestview_map.Get().insert(
 210       std::make_pair(guest_web_contents, this));
 211   GuestViewManager::FromBrowserContext(browser_context_)->
 212       AddGuest(guest_instance_id_, guest_web_contents);
 213
 214   // Populate the view instance ID if we have it on creation.
 215   create_params.GetInteger(kParameterInstanceId, &view_instance_id_);
 216
 217   if (CanRunInDetachedState())
 218     SetUpSizing(create_params);
 219
 220   // Observe guest zoom changes.
 221   auto zoom_controller =
 222       ui_zoom::ZoomController::FromWebContents(web_contents());
 223   zoom_controller->AddObserver(this);
 224
 225   // Give the derived class an opportunity to perform additional initialization.
 226   DidInitialize(create_params);
 227 }
 228
 229 void GuestViewBase::LoadURLWithParams(
 230       const content::NavigationController::LoadURLParams& load_params) {
 231   int guest_proxy_routing_id = host()->LoadURLWithParams(load_params);
 232   DCHECK(guest_proxy_routing_id_ == MSG_ROUTING_NONE ||
 233          guest_proxy_routing_id == guest_proxy_routing_id_);
 234   guest_proxy_routing_id_ = guest_proxy_routing_id;
 235 }
 236
 237 void GuestViewBase::DispatchOnResizeEvent(const gfx::Size& old_size,
 238                                           const gfx::Size& new_size) {
 239   if (new_size == old_size)
 240     return;
 241
 242   // Dispatch the onResize event.
 243   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
 244   args->SetInteger(kOldWidth, old_size.width());
 245   args->SetInteger(kOldHeight, old_size.height());
 246   args->SetInteger(kNewWidth, new_size.width());
 247   args->SetInteger(kNewHeight, new_size.height());
 248   DispatchEventToGuestProxy(new GuestViewEvent(kEventResize, args.Pass()));
 249 }
 250
 251 gfx::Size GuestViewBase::GetDefaultSize() const {
 252   if (is_full_page_plugin()) {
 253     // Full page plugins default to the size of the owner's viewport.
 254     return owner_web_contents()
 255         ->GetRenderWidgetHostView()
 256         ->GetVisibleViewportSize();
 257   } else {
 258     return gfx::Size(kDefaultWidth, kDefaultHeight);
 259   }
 260 }
 261
 262 void GuestViewBase::SetSize(const SetSizeParams& params) {
 263   bool enable_auto_size =
 264       params.enable_auto_size ? *params.enable_auto_size : auto_size_enabled_;
 265   gfx::Size min_size = params.min_size ? *params.min_size : min_auto_size_;
 266   gfx::Size max_size = params.max_size ? *params.max_size : max_auto_size_;
 267
 268   if (params.normal_size)
 269     normal_size_ = *params.normal_size;
 270
 271   min_auto_size_ = min_size;
 272   min_auto_size_.SetToMin(max_size);
 273   max_auto_size_ = max_size;
 274   max_auto_size_.SetToMax(min_size);
 275
 276   enable_auto_size &= !min_auto_size_.IsEmpty() && !max_auto_size_.IsEmpty() &&
 277                       IsAutoSizeSupported();
 278
 279   content::RenderViewHost* rvh = web_contents()->GetRenderViewHost();
 280   if (enable_auto_size) {
 281     // Autosize is being enabled.
 282     rvh->EnableAutoResize(min_auto_size_, max_auto_size_);
 283     normal_size_.SetSize(0, 0);
 284   } else {
 285     // Autosize is being disabled.
 286     // Use default width/height if missing from partially defined normal size.
 287     if (normal_size_.width() && !normal_size_.height())
 288       normal_size_.set_height(GetDefaultSize().height());
 289     if (!normal_size_.width() && normal_size_.height())
 290       normal_size_.set_width(GetDefaultSize().width());
 291
 292     gfx::Size new_size;
 293     if (!normal_size_.IsEmpty()) {
 294       new_size = normal_size_;
 295     } else if (!guest_size_.IsEmpty()) {
 296       new_size = guest_size_;
 297     } else {
 298       new_size = GetDefaultSize();
 299     }
 300
 301     if (auto_size_enabled_) {
 302       // Autosize was previously enabled.
 303       rvh->DisableAutoResize(new_size);
 304       GuestSizeChangedDueToAutoSize(guest_size_, new_size);
 305     } else {
 306       // Autosize was already disabled.
 307       guest_host_->SizeContents(new_size);
 308     }
 309
 310     DispatchOnResizeEvent(guest_size_, new_size);
 311     guest_size_ = new_size;
 312   }
 313
 314   auto_size_enabled_ = enable_auto_size;
 315 }
 316
 317 // static
 318 void GuestViewBase::CleanUp(content::BrowserContext* browser_context,
 319                             int embedder_process_id,
 320                             int view_instance_id) {
 321   // TODO(paulmeyer): Add in any general GuestView cleanup work here.
 322 }
 323
 324 // static
 325 GuestViewBase* GuestViewBase::FromWebContents(const WebContents* web_contents) {
 326   WebContentsGuestViewMap* guest_map = webcontents_guestview_map.Pointer();
 327   auto it = guest_map->find(web_contents);
 328   return it == guest_map->end() ? nullptr : it->second;
 329 }
 330
 331 // static
 332 GuestViewBase* GuestViewBase::From(int owner_process_id,
 333                                    int guest_instance_id) {
 334   auto host = content::RenderProcessHost::FromID(owner_process_id);
 335   if (!host)
 336     return nullptr;
 337
 338   WebContents* guest_web_contents =
 339       GuestViewManager::FromBrowserContext(host->GetBrowserContext())
 340           ->GetGuestByInstanceIDSafely(guest_instance_id, owner_process_id);
 341   if (!guest_web_contents)
 342     return nullptr;
 343
 344   return GuestViewBase::FromWebContents(guest_web_contents);
 345 }
 346
 347 // static
 348 WebContents* GuestViewBase::GetTopLevelWebContents(WebContents* web_contents) {
 349   while (GuestViewBase* guest = FromWebContents(web_contents))
 350     web_contents = guest->owner_web_contents();
 351   return web_contents;
 352 }
 353
 354 // static
 355 bool GuestViewBase::IsGuest(WebContents* web_contents) {
 356   return !!GuestViewBase::FromWebContents(web_contents);
 357 }
 358
 359 bool GuestViewBase::IsAutoSizeSupported() const {
 360   return false;
 361 }
 362
 363 bool GuestViewBase::IsPreferredSizeModeEnabled() const {
 364   return false;
 365 }
 366
 367 bool GuestViewBase::ZoomPropagatesFromEmbedderToGuest() const {
 368   return true;
 369 }
 370
 371 WebContents* GuestViewBase::CreateNewGuestWindow(
 372     const WebContents::CreateParams& create_params) {
 373   auto guest_manager = GuestViewManager::FromBrowserContext(browser_context());
 374   return guest_manager->CreateGuestWithWebContentsParams(
 375       GetViewType(),
 376       owner_web_contents(),
 377       create_params);
 378 }
 379
 380 void GuestViewBase::DidAttach(int guest_proxy_routing_id) {
 381   DCHECK(guest_proxy_routing_id_ == MSG_ROUTING_NONE ||
 382          guest_proxy_routing_id == guest_proxy_routing_id_);
 383   guest_proxy_routing_id_ = guest_proxy_routing_id;
 384
 385   opener_lifetime_observer_.reset();
 386
 387   SetUpSizing(*attach_params());
 388
 389   // Give the derived class an opportunity to perform some actions.
 390   DidAttachToEmbedder();
 391
 392   // Inform the associated GuestViewContainer that the contentWindow is ready.
 393   embedder_web_contents()->Send(new GuestViewMsg_GuestAttached(
 394       element_instance_id_,
 395       guest_proxy_routing_id));
 396
 397   SendQueuedEvents();
 398 }
 399
 400 void GuestViewBase::DidDetach() {
 401   GuestViewManager::FromBrowserContext(browser_context_)->DetachGuest(this);
 402   StopTrackingEmbedderZoomLevel();
 403   owner_web_contents()->Send(new GuestViewMsg_GuestDetached(
 404       element_instance_id_));
 405   element_instance_id_ = kInstanceIDNone;
 406 }
 407
 408 bool GuestViewBase::Find(int request_id,
 409                          const base::string16& search_text,
 410                          const blink::WebFindOptions& options) {
 411   if (ShouldHandleFindRequestsForEmbedder()) {
 412     web_contents()->Find(request_id, search_text, options);
 413     return true;
 414   }
 415   return false;
 416 }
 417
 418 bool GuestViewBase::StopFinding(content::StopFindAction action) {
 419   if (ShouldHandleFindRequestsForEmbedder()) {
 420     web_contents()->StopFinding(action);
 421     return true;
 422   }
 423   return false;
 424 }
 425
 426 WebContents* GuestViewBase::GetOwnerWebContents() const {
 427   return owner_web_contents_;
 428 }
 429
 430 void GuestViewBase::GuestSizeChanged(const gfx::Size& new_size) {
 431   if (!auto_size_enabled_)
 432     return;
 433   GuestSizeChangedDueToAutoSize(guest_size_, new_size);
 434   DispatchOnResizeEvent(guest_size_, new_size);
 435   guest_size_ = new_size;
 436 }
 437
 438 const GURL& GuestViewBase::GetOwnerSiteURL() const {
 439   return owner_web_contents()->GetLastCommittedURL();
 440 }
 441
 442 void GuestViewBase::Destroy() {
 443   if (is_being_destroyed_)
 444     return;
 445
 446   is_being_destroyed_ = true;
 447
 448   // It is important to clear owner_web_contents_ after the call to
 449   // StopTrackingEmbedderZoomLevel(), but before the rest of
 450   // the statements in this function.
 451   StopTrackingEmbedderZoomLevel();
 452   owner_web_contents_ = nullptr;
 453
 454   DCHECK(web_contents());
 455
 456   // Give the derived class an opportunity to perform some cleanup.
 457   WillDestroy();
 458
 459   // Invalidate weak pointers now so that bound callbacks cannot be called late
 460   // into destruction. We must call this after WillDestroy because derived types
 461   // may wish to access their openers.
 462   weak_ptr_factory_.InvalidateWeakPtrs();
 463
 464   // Give the content module an opportunity to perform some cleanup.
 465   guest_host_->WillDestroy();
 466   guest_host_ = nullptr;
 467
 468   webcontents_guestview_map.Get().erase(web_contents());
 469   GuestViewManager::FromBrowserContext(browser_context_)->
 470       RemoveGuest(guest_instance_id_);
 471   pending_events_.clear();
 472
 473   delete web_contents();
 474 }
 475
 476 void GuestViewBase::SetAttachParams(const base::DictionaryValue& params) {
 477   attach_params_.reset(params.DeepCopy());
 478   attach_params_->GetInteger(kParameterInstanceId, &view_instance_id_);
 479 }
 480
 481 void GuestViewBase::SetOpener(GuestViewBase* guest) {
 482   if (guest && guest->IsViewType(GetViewType())) {
 483     opener_ = guest->weak_ptr_factory_.GetWeakPtr();
 484     if (!attached())
 485       opener_lifetime_observer_.reset(new OpenerLifetimeObserver(this));
 486     return;
 487   }
 488   opener_ = base::WeakPtr<GuestViewBase>();
 489   opener_lifetime_observer_.reset();
 490 }
 491
 492 void GuestViewBase::SetGuestHost(content::GuestHost* guest_host) {
 493   guest_host_ = guest_host;
 494 }
 495
 496 void GuestViewBase::WillAttach(WebContents* embedder_web_contents,
 497                                int element_instance_id,
 498                                bool is_full_page_plugin,
 499                                const base::Closure& callback) {
 500   // Stop tracking the old embedder's zoom level.
 501   if (owner_web_contents())
 502     StopTrackingEmbedderZoomLevel();
 503
 504   if (owner_web_contents_ != embedder_web_contents) {
 505     DCHECK_EQ(owner_contents_observer_->web_contents(), owner_web_contents_);
 506     owner_web_contents_ = embedder_web_contents;
 507     owner_contents_observer_.reset(
 508         new OwnerContentsObserver(this, embedder_web_contents));
 509     owner_host_ = GuestViewManager::FromBrowserContext(browser_context_)->
 510         IsOwnedByExtension(this) ?
 511             owner_web_contents()->GetLastCommittedURL().host() : std::string();
 512   }
 513
 514   // Start tracking the new embedder's zoom level.
 515   StartTrackingEmbedderZoomLevel();
 516   element_instance_id_ = element_instance_id;
 517   is_full_page_plugin_ = is_full_page_plugin;
 518
 519   WillAttachToEmbedder();
 520
 521   // Completing attachment will resume suspended resource loads and then send
 522   // queued events.
 523   SignalWhenReady(callback);
 524 }
 525
 526 void GuestViewBase::SignalWhenReady(const base::Closure& callback) {
 527   // The default behavior is to call the |callback| immediately. Derived classes
 528   // can implement an alternative signal for readiness.
 529   callback.Run();
 530 }
 531
 532 bool GuestViewBase::ShouldHandleFindRequestsForEmbedder() const {
 533   return false;
 534 }
 535
 536 int GuestViewBase::LogicalPixelsToPhysicalPixels(double logical_pixels) const {
 537   DCHECK(logical_pixels >= 0);
 538   double zoom_factor = GetEmbedderZoomFactor();
 539   return lround(logical_pixels * zoom_factor);
 540 }
 541
 542 double GuestViewBase::PhysicalPixelsToLogicalPixels(int physical_pixels) const {
 543   DCHECK(physical_pixels >= 0);
 544   double zoom_factor = GetEmbedderZoomFactor();
 545   return physical_pixels / zoom_factor;
 546 }
 547
 548 void GuestViewBase::DidStopLoading() {
 549   content::RenderViewHost* rvh = web_contents()->GetRenderViewHost();
 550
 551   if (IsPreferredSizeModeEnabled())
 552     rvh->EnablePreferredSizeMode();
 553   GuestViewDidStopLoading();
 554 }
 555
 556 void GuestViewBase::RenderViewReady() {
 557   GuestReady();
 558 }
 559
 560 void GuestViewBase::WebContentsDestroyed() {
 561   // Let the derived class know that its WebContents is in the process of
 562   // being destroyed. web_contents() is still valid at this point.
 563   // TODO(fsamuel): This allows for reentrant code into WebContents during
 564   // destruction. This could potentially lead to bugs. Perhaps we should get rid
 565   // of this?
 566   GuestDestroyed();
 567
 568   // Self-destruct.
 569   delete this;
 570 }
 571
 572 void GuestViewBase::DidNavigateMainFrame(
 573     const content::LoadCommittedDetails& details,
 574     const content::FrameNavigateParams& params) {
 575   if (attached() && ZoomPropagatesFromEmbedderToGuest())
 576     SetGuestZoomLevelToMatchEmbedder();
 577
 578   // TODO(lazyboy): This breaks guest visibility in --site-per-process because
 579   // we do not take the widget's visibility into account.  We need to also
 580   // stay hidden during "visibility:none" state.
 581   if (content::BrowserPluginGuestMode::UseCrossProcessFramesForGuests()) {
 582     web_contents()->WasShown();
 583   }
 584 }
 585
 586 void GuestViewBase::ActivateContents(WebContents* web_contents) {
 587   if (!attached() || !embedder_web_contents()->GetDelegate())
 588     return;
 589
 590   embedder_web_contents()->GetDelegate()->ActivateContents(
 591       embedder_web_contents());
 592 }
 593
 594 void GuestViewBase::DeactivateContents(WebContents* web_contents) {
 595   if (!attached() || !embedder_web_contents()->GetDelegate())
 596     return;
 597
 598   embedder_web_contents()->GetDelegate()->DeactivateContents(
 599       embedder_web_contents());
 600 }
 601
 602 void GuestViewBase::ContentsMouseEvent(WebContents* source,
 603                                        const gfx::Point& location,
 604                                        bool motion) {
 605   if (!attached() || !embedder_web_contents()->GetDelegate())
 606     return;
 607
 608   embedder_web_contents()->GetDelegate()->ContentsMouseEvent(
 609       embedder_web_contents(), location, motion);
 610 }
 611
 612 void GuestViewBase::ContentsZoomChange(bool zoom_in) {
 613   ui_zoom::PageZoom::Zoom(
 614       embedder_web_contents(),
 615       zoom_in ? content::PAGE_ZOOM_IN : content::PAGE_ZOOM_OUT);
 616 }
 617
 618 void GuestViewBase::HandleKeyboardEvent(
 619     WebContents* source,
 620     const content::NativeWebKeyboardEvent& event) {
 621   if (!attached())
 622     return;
 623
 624   // Send the keyboard events back to the embedder to reprocess them.
 625   embedder_web_contents()->GetDelegate()->
 626       HandleKeyboardEvent(embedder_web_contents(), event);
 627 }
 628
 629 void GuestViewBase::LoadingStateChanged(WebContents* source,
 630                                         bool to_different_document) {
 631   if (!attached() || !embedder_web_contents()->GetDelegate())
 632     return;
 633
 634   embedder_web_contents()->GetDelegate()->LoadingStateChanged(
 635       embedder_web_contents(), to_different_document);
 636 }
 637
 638 content::ColorChooser* GuestViewBase::OpenColorChooser(
 639     WebContents* web_contents,
 640     SkColor color,
 641     const std::vector<content::ColorSuggestion>& suggestions) {
 642   if (!attached() || !embedder_web_contents()->GetDelegate())
 643     return nullptr;
 644
 645   return embedder_web_contents()->GetDelegate()->OpenColorChooser(
 646       web_contents, color, suggestions);
 647 }
 648
 649 void GuestViewBase::RunFileChooser(WebContents* web_contents,
 650                                    const content::FileChooserParams& params) {
 651   if (!attached() || !embedder_web_contents()->GetDelegate())
 652     return;
 653
 654   embedder_web_contents()->GetDelegate()->RunFileChooser(web_contents, params);
 655 }
 656
 657 bool GuestViewBase::ShouldFocusPageAfterCrash() {
 658   // Focus is managed elsewhere.
 659   return false;
 660 }
 661
 662 bool GuestViewBase::PreHandleGestureEvent(WebContents* source,
 663                                           const blink::WebGestureEvent& event) {
 664   return event.type == blink::WebGestureEvent::GesturePinchBegin ||
 665       event.type == blink::WebGestureEvent::GesturePinchUpdate ||
 666       event.type == blink::WebGestureEvent::GesturePinchEnd;
 667 }
 668
 669 void GuestViewBase::UpdatePreferredSize(WebContents* target_web_contents,
 670                                         const gfx::Size& pref_size) {
 671   // In theory it's not necessary to check IsPreferredSizeModeEnabled() because
 672   // there will only be events if it was enabled in the first place. However,
 673   // something else may have turned on preferred size mode, so double check.
 674   DCHECK_EQ(web_contents(), target_web_contents);
 675   if (IsPreferredSizeModeEnabled()) {
 676     OnPreferredSizeChanged(pref_size);
 677   }
 678 }
 679
 680 void GuestViewBase::UpdateTargetURL(WebContents* source, const GURL& url) {
 681   if (!attached() || !embedder_web_contents()->GetDelegate())
 682     return;
 683
 684   embedder_web_contents()->GetDelegate()->UpdateTargetURL(
 685       embedder_web_contents(), url);
 686 }
 687
 688 bool GuestViewBase::ShouldResumeRequestsForCreatedWindow() {
 689   return false;
 690 }
 691
 692 void GuestViewBase::FindReply(WebContents* source,
 693                               int request_id,
 694                               int number_of_matches,
 695                               const gfx::Rect& selection_rect,
 696                               int active_match_ordinal,
 697                               bool final_update) {
 698   if (ShouldHandleFindRequestsForEmbedder() &&
 699       attached() && embedder_web_contents()->GetDelegate()) {
 700     embedder_web_contents()->GetDelegate()->FindReply(embedder_web_contents(),
 701                                                       request_id,
 702                                                       number_of_matches,
 703                                                       selection_rect,
 704                                                       active_match_ordinal,
 705                                                       final_update);
 706   }
 707 }
 708
 709 GuestViewBase::~GuestViewBase() {
 710 }
 711
 712 void GuestViewBase::OnZoomChanged(
 713     const ui_zoom::ZoomController::ZoomChangedEventData& data) {
 714   if (data.web_contents == embedder_web_contents()) {
 715     // The embedder's zoom level has changed.
 716     auto guest_zoom_controller =
 717         ui_zoom::ZoomController::FromWebContents(web_contents());
 718     if (content::ZoomValuesEqual(data.new_zoom_level,
 719                                  guest_zoom_controller->GetZoomLevel())) {
 720       return;
 721     }
 722     // When the embedder's zoom level doesn't match the guest's, then update the
 723     // guest's zoom level to match.
 724     guest_zoom_controller->SetZoomLevel(data.new_zoom_level);
 725
 726     EmbedderZoomChanged(data.old_zoom_level, data.new_zoom_level);
 727     return;
 728   }
 729
 730   if (data.web_contents == web_contents()) {
 731     // The guest's zoom level has changed.
 732     GuestZoomChanged(data.old_zoom_level, data.new_zoom_level);
 733   }
 734 }
 735
 736 void GuestViewBase::DispatchEventToGuestProxy(GuestViewEvent* event) {
 737   event->Dispatch(this, guest_instance_id_);
 738 }
 739
 740 void GuestViewBase::DispatchEventToView(GuestViewEvent* event) {
 741   if (!attached() &&
 742       (!CanRunInDetachedState() || !can_owner_receive_events())) {
 743     pending_events_.push_back(linked_ptr<GuestViewEvent>(event));
 744     return;
 745   }
 746
 747   event->Dispatch(this, view_instance_id_);
 748 }
 749
 750 void GuestViewBase::SendQueuedEvents() {
 751   if (!attached())
 752     return;
 753   while (!pending_events_.empty()) {
 754     linked_ptr<GuestViewEvent> event_ptr = pending_events_.front();
 755     pending_events_.pop_front();
 756     event_ptr.release()->Dispatch(this, view_instance_id_);
 757   }
 758 }
 759
 760 void GuestViewBase::CompleteInit(
 761     scoped_ptr<base::DictionaryValue> create_params,
 762     const WebContentsCreatedCallback& callback,
 763     WebContents* guest_web_contents) {
 764   if (!guest_web_contents) {
 765     // The derived class did not create a WebContents so this class serves no
 766     // purpose. Let's self-destruct.
 767     delete this;
 768     callback.Run(nullptr);
 769     return;
 770   }
 771   InitWithWebContents(*create_params, guest_web_contents);
 772   callback.Run(guest_web_contents);
 773 }
 774
 775 double GuestViewBase::GetEmbedderZoomFactor() const {
 776   if (!embedder_web_contents())
 777     return 1.0;
 778
 779   return content::ZoomLevelToZoomFactor(
 780       ui_zoom::ZoomController::GetZoomLevelForWebContents(
 781           embedder_web_contents()));
 782 }
 783
 784 void GuestViewBase::SetUpSizing(const base::DictionaryValue& params) {
 785   // Read the autosize parameters passed in from the embedder.
 786   bool auto_size_enabled = auto_size_enabled_;
 787   params.GetBoolean(kAttributeAutoSize, &auto_size_enabled);
 788
 789   int max_height = max_auto_size_.height();
 790   int max_width = max_auto_size_.width();
 791   params.GetInteger(kAttributeMaxHeight, &max_height);
 792   params.GetInteger(kAttributeMaxWidth, &max_width);
 793
 794   int min_height = min_auto_size_.height();
 795   int min_width = min_auto_size_.width();
 796   params.GetInteger(kAttributeMinHeight, &min_height);
 797   params.GetInteger(kAttributeMinWidth, &min_width);
 798
 799   double element_height = 0.0;
 800   double element_width = 0.0;
 801   params.GetDouble(kElementHeight, &element_height);
 802   params.GetDouble(kElementWidth, &element_width);
 803
 804   // Set the normal size to the element size so that the guestview will fit
 805   // the element initially if autosize is disabled.
 806   int normal_height = normal_size_.height();
 807   int normal_width = normal_size_.width();
 808   // If the element size was provided in logical units (versus physical), then
 809   // it will be converted to physical units.
 810   bool element_size_is_logical = false;
 811   params.GetBoolean(kElementSizeIsLogical, &element_size_is_logical);
 812   if (element_size_is_logical) {
 813     // Convert the element size from logical pixels to physical pixels.
 814     normal_height = LogicalPixelsToPhysicalPixels(element_height);
 815     normal_width = LogicalPixelsToPhysicalPixels(element_width);
 816   } else {
 817     normal_height = lround(element_height);
 818     normal_width = lround(element_width);
 819   }
 820
 821   SetSizeParams set_size_params;
 822   set_size_params.enable_auto_size.reset(new bool(auto_size_enabled));
 823   set_size_params.min_size.reset(new gfx::Size(min_width, min_height));
 824   set_size_params.max_size.reset(new gfx::Size(max_width, max_height));
 825   set_size_params.normal_size.reset(new gfx::Size(normal_width, normal_height));
 826
 827   // Call SetSize to apply all the appropriate validation and clipping of
 828   // values.
 829   SetSize(set_size_params);
 830 }
 831
 832 void GuestViewBase::SetGuestZoomLevelToMatchEmbedder() {
 833   auto embedder_zoom_controller =
 834       ui_zoom::ZoomController::FromWebContents(owner_web_contents());
 835   if (!embedder_zoom_controller)
 836     return;
 837
 838   ui_zoom::ZoomController::FromWebContents(web_contents())
 839       ->SetZoomLevel(embedder_zoom_controller->GetZoomLevel());
 840 }
 841
 842 void GuestViewBase::StartTrackingEmbedderZoomLevel() {
 843   if (!ZoomPropagatesFromEmbedderToGuest())
 844     return;
 845
 846   auto embedder_zoom_controller =
 847       ui_zoom::ZoomController::FromWebContents(owner_web_contents());
 848   // Chrome Apps do not have a ZoomController.
 849   if (!embedder_zoom_controller)
 850     return;
 851   // Listen to the embedder's zoom changes.
 852   embedder_zoom_controller->AddObserver(this);
 853
 854   // Set the guest's initial zoom level to be equal to the embedder's.
 855   SetGuestZoomLevelToMatchEmbedder();
 856 }
 857
 858 void GuestViewBase::StopTrackingEmbedderZoomLevel() {
 859   if (!attached() || !ZoomPropagatesFromEmbedderToGuest())
 860     return;
 861
 862   auto embedder_zoom_controller =
 863       ui_zoom::ZoomController::FromWebContents(owner_web_contents());
 864   // Chrome Apps do not have a ZoomController.
 865   if (!embedder_zoom_controller)
 866     return;
 867   embedder_zoom_controller->RemoveObserver(this);
 868 }
 869
 870 }  // namespace guest_view