content/browser/web_contents/web_contents_impl.cc

   1 // Copyright (c) 2012 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 "content/browser/web_contents/web_contents_impl.h"
   6
   7 #include <utility>
   8
   9 #include "base/command_line.h"
  10 #include "base/debug/trace_event.h"
  11 #include "base/lazy_instance.h"
  12 #include "base/logging.h"
  13 #include "base/metrics/histogram.h"
  14 #include "base/metrics/stats_counters.h"
  15 #include "base/process/process.h"
  16 #include "base/strings/string16.h"
  17 #include "base/strings/string_number_conversions.h"
  18 #include "base/strings/string_util.h"
  19 #include "base/strings/utf_string_conversions.h"
  20 #include "base/time/time.h"
  21 #include "content/browser/accessibility/accessibility_mode_helper.h"
  22 #include "content/browser/accessibility/browser_accessibility_state_impl.h"
  23 #include "content/browser/browser_plugin/browser_plugin_embedder.h"
  24 #include "content/browser/browser_plugin/browser_plugin_guest.h"
  25 #include "content/browser/child_process_security_policy_impl.h"
  26 #include "content/browser/devtools/render_view_devtools_agent_host.h"
  27 #include "content/browser/dom_storage/dom_storage_context_wrapper.h"
  28 #include "content/browser/dom_storage/session_storage_namespace_impl.h"
  29 #include "content/browser/download/download_stats.h"
  30 #include "content/browser/download/mhtml_generation_manager.h"
  31 #include "content/browser/download/save_package.h"
  32 #include "content/browser/frame_host/cross_process_frame_connector.h"
  33 #include "content/browser/frame_host/interstitial_page_impl.h"
  34 #include "content/browser/frame_host/navigation_entry_impl.h"
  35 #include "content/browser/frame_host/navigator_impl.h"
  36 #include "content/browser/frame_host/render_frame_host_impl.h"
  37 #include "content/browser/frame_host/render_widget_host_view_child_frame.h"
  38 #include "content/browser/geolocation/geolocation_dispatcher_host.h"
  39 #include "content/browser/host_zoom_map_impl.h"
  40 #include "content/browser/loader/resource_dispatcher_host_impl.h"
  41 #include "content/browser/media/midi_dispatcher_host.h"
  42 #include "content/browser/message_port_message_filter.h"
  43 #include "content/browser/message_port_service.h"
  44 #include "content/browser/power_save_blocker_impl.h"
  45 #include "content/browser/renderer_host/render_process_host_impl.h"
  46 #include "content/browser/renderer_host/render_view_host_delegate_view.h"
  47 #include "content/browser/renderer_host/render_view_host_impl.h"
  48 #include "content/browser/renderer_host/render_widget_host_impl.h"
  49 #include "content/browser/renderer_host/render_widget_host_view_base.h"
  50 #include "content/browser/screen_orientation/screen_orientation_dispatcher_host.h"
  51 #include "content/browser/site_instance_impl.h"
  52 #include "content/browser/web_contents/web_contents_view_guest.h"
  53 #include "content/browser/webui/generic_handler.h"
  54 #include "content/browser/webui/web_ui_controller_factory_registry.h"
  55 #include "content/browser/webui/web_ui_impl.h"
  56 #include "content/common/browser_plugin/browser_plugin_constants.h"
  57 #include "content/common/browser_plugin/browser_plugin_messages.h"
  58 #include "content/common/frame_messages.h"
  59 #include "content/common/image_messages.h"
  60 #include "content/common/input_messages.h"
  61 #include "content/common/ssl_status_serialization.h"
  62 #include "content/common/view_messages.h"
  63 #include "content/public/browser/ax_event_notification_details.h"
  64 #include "content/public/browser/browser_context.h"
  65 #include "content/public/browser/browser_plugin_guest_manager.h"
  66 #include "content/public/browser/content_browser_client.h"
  67 #include "content/public/browser/devtools_agent_host.h"
  68 #include "content/public/browser/download_manager.h"
  69 #include "content/public/browser/download_url_parameters.h"
  70 #include "content/public/browser/invalidate_type.h"
  71 #include "content/public/browser/javascript_dialog_manager.h"
  72 #include "content/public/browser/load_from_memory_cache_details.h"
  73 #include "content/public/browser/load_notification_details.h"
  74 #include "content/public/browser/navigation_details.h"
  75 #include "content/public/browser/notification_details.h"
  76 #include "content/public/browser/notification_service.h"
  77 #include "content/public/browser/render_widget_host_iterator.h"
  78 #include "content/public/browser/resource_request_details.h"
  79 #include "content/public/browser/storage_partition.h"
  80 #include "content/public/browser/user_metrics.h"
  81 #include "content/public/browser/web_contents_delegate.h"
  82 #include "content/public/browser/web_contents_observer.h"
  83 #include "content/public/common/bindings_policy.h"
  84 #include "content/public/common/content_constants.h"
  85 #include "content/public/common/content_switches.h"
  86 #include "content/public/common/page_zoom.h"
  87 #include "content/public/common/result_codes.h"
  88 #include "content/public/common/url_constants.h"
  89 #include "content/public/common/url_utils.h"
  90 #include "content/public/common/web_preferences.h"
  91 #include "net/base/mime_util.h"
  92 #include "net/base/net_util.h"
  93 #include "net/http/http_cache.h"
  94 #include "net/http/http_transaction_factory.h"
  95 #include "net/url_request/url_request_context.h"
  96 #include "net/url_request/url_request_context_getter.h"
  97 #include "ui/base/layout.h"
  98 #include "ui/gfx/display.h"
  99 #include "ui/gfx/screen.h"
 100 #include "ui/gl/gl_switches.h"
 101
 102 #if defined(OS_ANDROID)
 103 #include "content/browser/android/content_view_core_impl.h"
 104 #include "content/browser/android/date_time_chooser_android.h"
 105 #include "content/browser/media/android/browser_media_player_manager.h"
 106 #include "content/browser/web_contents/web_contents_android.h"
 107 #include "content/public/browser/android/content_view_core.h"
 108 #endif
 109
 110 #if defined(OS_MACOSX)
 111 #include "base/mac/foundation_util.h"
 112 #endif
 113
 114 // Cross-Site Navigations
 115 //
 116 // If a WebContentsImpl is told to navigate to a different web site (as
 117 // determined by SiteInstance), it will replace its current RenderViewHost with
 118 // a new RenderViewHost dedicated to the new SiteInstance.  This works as
 119 // follows:
 120 //
 121 // - RVHM::Navigate determines whether the destination is cross-site, and if so,
 122 //   it creates a pending_render_view_host_.
 123 // - The pending RVH is "suspended," so that no navigation messages are sent to
 124 //   its renderer until the beforeunload JavaScript handler has a chance to
 125 //   run in the current RVH.
 126 // - The pending RVH tells CrossSiteRequestManager (a thread-safe singleton)
 127 //   that it has a pending cross-site request.  We will check this on the IO
 128 //   thread when deciding how to handle the response.
 129 // - The current RVH runs its beforeunload handler.  If it returns false, we
 130 //   cancel all the pending logic.  Otherwise we allow the pending RVH to send
 131 //   the navigation request to its renderer.
 132 // - ResourceDispatcherHost receives a ResourceRequest on the IO thread for the
 133 //   main resource load on the pending RVH.  It creates a
 134 //   CrossSiteResourceHandler to check whether a process swap is needed when
 135 //   the request is ready to commit.
 136 // - When RDH receives a response, the BufferedResourceHandler determines
 137 //   whether it is a download.  If so, it sends a message to the new renderer
 138 //   causing it to cancel the request, and the download proceeds. For now, the
 139 //   pending RVH remains until the next DidNavigate event for this
 140 //   WebContentsImpl. This isn't ideal, but it doesn't affect any functionality.
 141 // - After RDH receives a response and determines that it is safe and not a
 142 //   download, the CrossSiteResourceHandler checks whether a process swap is
 143 //   needed (either because CrossSiteRequestManager has state for it or because
 144 //   a transfer was needed for a redirect).
 145 // - If so, CrossSiteResourceHandler pauses the response to first run the old
 146 //   page's unload handler.  It does this by asynchronously calling the
 147 //   OnCrossSiteResponse method of RenderFrameHostManager on the UI thread,
 148 //   which sends a SwapOut message to the current RVH.
 149 // - Once the unload handler is finished, RVHM::SwappedOut checks if a transfer
 150 //   to a new process is needed, based on the stored pending_nav_params_.  (This
 151 //   is independent of whether we started out with a cross-process navigation.)
 152 //   - If not, it just tells the ResourceDispatcherHost to resume the response
 153 //     to its current RenderViewHost.
 154 //   - If so, it cancels the current pending RenderViewHost and sets up a new
 155 //     navigation using RequestTransferURL.  When the transferred request
 156 //     arrives in the ResourceDispatcherHost, we transfer the response and
 157 //     resume it.
 158 // - The pending renderer sends a FrameNavigate message that invokes the
 159 //   DidNavigate method.  This replaces the current RVH with the
 160 //   pending RVH.
 161 // - The previous renderer is kept swapped out in RenderFrameHostManager in case
 162 //   the user goes back.  The process only stays live if another tab is using
 163 //   it, but if so, the existing frame relationships will be maintained.
 164
 165 namespace content {
 166 namespace {
 167
 168 const int kMinimumDelayBetweenLoadingUpdatesMS = 100;
 169
 170 // This matches what Blink's ProgressTracker has traditionally used for a
 171 // minimum progress value.
 172 const double kMinimumLoadingProgress = 0.1;
 173
 174 const char kDotGoogleDotCom[] = ".google.com";
 175
 176 #if defined(OS_ANDROID)
 177 const char kWebContentsAndroidKey[] = "web_contents_android";
 178 #endif  // OS_ANDROID
 179
 180 base::LazyInstance<std::vector<WebContentsImpl::CreatedCallback> >
 181 g_created_callbacks = LAZY_INSTANCE_INITIALIZER;
 182
 183 static int StartDownload(content::RenderFrameHost* rfh,
 184                          const GURL& url,
 185                          bool is_favicon,
 186                          uint32_t max_bitmap_size) {
 187   static int g_next_image_download_id = 0;
 188   rfh->Send(new ImageMsg_DownloadImage(rfh->GetRoutingID(),
 189                                        ++g_next_image_download_id,
 190                                        url,
 191                                        is_favicon,
 192                                        max_bitmap_size));
 193   return g_next_image_download_id;
 194 }
 195
 196 void NotifyCacheOnIO(
 197     scoped_refptr<net::URLRequestContextGetter> request_context,
 198     const GURL& url,
 199     const std::string& http_method) {
 200   request_context->GetURLRequestContext()->http_transaction_factory()->
 201       GetCache()->OnExternalCacheHit(url, http_method);
 202 }
 203
 204 // Helper function for retrieving all the sites in a frame tree.
 205 bool CollectSites(BrowserContext* context,
 206                   std::set<GURL>* sites,
 207                   FrameTreeNode* node) {
 208   sites->insert(SiteInstance::GetSiteForURL(context, node->current_url()));
 209   return true;
 210 }
 211
 212 bool ForEachFrameInternal(
 213     const base::Callback<void(RenderFrameHost*)>& on_frame,
 214     FrameTreeNode* node) {
 215   on_frame.Run(node->current_frame_host());
 216   return true;
 217 }
 218
 219 bool ForEachPendingFrameInternal(
 220     const base::Callback<void(RenderFrameHost*)>& on_frame,
 221     FrameTreeNode* node) {
 222   RenderFrameHost* pending_frame_host =
 223       node->render_manager()->pending_frame_host();
 224   if (pending_frame_host)
 225     on_frame.Run(pending_frame_host);
 226   return true;
 227 }
 228
 229 void SendToAllFramesInternal(IPC::Message* message, RenderFrameHost* rfh) {
 230   IPC::Message* message_copy = new IPC::Message(*message);
 231   message_copy->set_routing_id(rfh->GetRoutingID());
 232   rfh->Send(message_copy);
 233 }
 234
 235 void AddRenderWidgetHostViewToSet(std::set<RenderWidgetHostView*>* set,
 236                                   RenderFrameHost* rfh) {
 237   RenderWidgetHostView* rwhv = static_cast<RenderFrameHostImpl*>(rfh)
 238                                    ->frame_tree_node()
 239                                    ->render_manager()
 240                                    ->GetRenderWidgetHostView();
 241   set->insert(rwhv);
 242 }
 243
 244 void SetAccessibilityModeOnFrame(AccessibilityMode mode,
 245                                  RenderFrameHost* frame_host) {
 246   static_cast<RenderFrameHostImpl*>(frame_host)->SetAccessibilityMode(mode);
 247 }
 248
 249 }  // namespace
 250
 251 WebContents* WebContents::Create(const WebContents::CreateParams& params) {
 252   return WebContentsImpl::CreateWithOpener(
 253       params, static_cast<WebContentsImpl*>(params.opener));
 254 }
 255
 256 WebContents* WebContents::CreateWithSessionStorage(
 257     const WebContents::CreateParams& params,
 258     const SessionStorageNamespaceMap& session_storage_namespace_map) {
 259   WebContentsImpl* new_contents = new WebContentsImpl(
 260       params.browser_context, NULL);
 261
 262   for (SessionStorageNamespaceMap::const_iterator it =
 263            session_storage_namespace_map.begin();
 264        it != session_storage_namespace_map.end();
 265        ++it) {
 266     new_contents->GetController()
 267         .SetSessionStorageNamespace(it->first, it->second.get());
 268   }
 269
 270   new_contents->Init(params);
 271   return new_contents;
 272 }
 273
 274 void WebContentsImpl::AddCreatedCallback(const CreatedCallback& callback) {
 275   g_created_callbacks.Get().push_back(callback);
 276 }
 277
 278 void WebContentsImpl::RemoveCreatedCallback(const CreatedCallback& callback) {
 279   for (size_t i = 0; i < g_created_callbacks.Get().size(); ++i) {
 280     if (g_created_callbacks.Get().at(i).Equals(callback)) {
 281       g_created_callbacks.Get().erase(g_created_callbacks.Get().begin() + i);
 282       return;
 283     }
 284   }
 285 }
 286
 287 WebContents* WebContents::FromRenderViewHost(const RenderViewHost* rvh) {
 288   return rvh->GetDelegate()->GetAsWebContents();
 289 }
 290
 291 WebContents* WebContents::FromRenderFrameHost(RenderFrameHost* rfh) {
 292   RenderFrameHostImpl* rfh_impl = static_cast<RenderFrameHostImpl*>(rfh);
 293   if (!rfh_impl)
 294     return NULL;
 295   return rfh_impl->delegate()->GetAsWebContents();
 296 }
 297
 298 // WebContentsImpl::DestructionObserver ----------------------------------------
 299
 300 class WebContentsImpl::DestructionObserver : public WebContentsObserver {
 301  public:
 302   DestructionObserver(WebContentsImpl* owner, WebContents* watched_contents)
 303       : WebContentsObserver(watched_contents),
 304         owner_(owner) {
 305   }
 306
 307   // WebContentsObserver:
 308   virtual void WebContentsDestroyed() OVERRIDE {
 309     owner_->OnWebContentsDestroyed(
 310         static_cast<WebContentsImpl*>(web_contents()));
 311   }
 312
 313  private:
 314   WebContentsImpl* owner_;
 315
 316   DISALLOW_COPY_AND_ASSIGN(DestructionObserver);
 317 };
 318
 319 WebContentsImpl::ColorChooserInfo::ColorChooserInfo(int render_process_id,
 320                                                     int render_frame_id,
 321                                                     ColorChooser* chooser,
 322                                                     int identifier)
 323     : render_process_id(render_process_id),
 324       render_frame_id(render_frame_id),
 325       chooser(chooser),
 326       identifier(identifier) {
 327 }
 328
 329 WebContentsImpl::ColorChooserInfo::~ColorChooserInfo() {
 330 }
 331
 332 // WebContentsImpl -------------------------------------------------------------
 333
 334 WebContentsImpl::WebContentsImpl(
 335     BrowserContext* browser_context,
 336     WebContentsImpl* opener)
 337     : delegate_(NULL),
 338       controller_(this, browser_context),
 339       render_view_host_delegate_view_(NULL),
 340       opener_(opener),
 341       created_with_opener_(!!opener),
 342 #if defined(OS_WIN)
 343       accessible_parent_(NULL),
 344 #endif
 345       frame_tree_(new NavigatorImpl(&controller_, this),
 346                   this, this, this, this),
 347       is_loading_(false),
 348       is_load_to_different_document_(false),
 349       crashed_status_(base::TERMINATION_STATUS_STILL_RUNNING),
 350       crashed_error_code_(0),
 351       waiting_for_response_(false),
 352       load_state_(net::LOAD_STATE_IDLE, base::string16()),
 353       loading_total_progress_(0.0),
 354       loading_weak_factory_(this),
 355       loading_frames_in_progress_(0),
 356       upload_size_(0),
 357       upload_position_(0),
 358       displayed_insecure_content_(false),
 359       has_accessed_initial_document_(false),
 360       capturer_count_(0),
 361       should_normally_be_visible_(true),
 362       is_being_destroyed_(false),
 363       notify_disconnection_(false),
 364       dialog_manager_(NULL),
 365       is_showing_before_unload_dialog_(false),
 366       last_active_time_(base::TimeTicks::Now()),
 367       closed_by_user_gesture_(false),
 368       minimum_zoom_percent_(static_cast<int>(kMinimumZoomFactor * 100)),
 369       maximum_zoom_percent_(static_cast<int>(kMaximumZoomFactor * 100)),
 370       totalPinchGestureAmount_(0),
 371       currentPinchZoomStepDelta_(0),
 372       render_view_message_source_(NULL),
 373       fullscreen_widget_routing_id_(MSG_ROUTING_NONE),
 374       fullscreen_widget_had_focus_at_shutdown_(false),
 375       is_subframe_(false),
 376       force_disable_overscroll_content_(false),
 377       last_dialog_suppressed_(false),
 378       accessibility_mode_(
 379           BrowserAccessibilityStateImpl::GetInstance()->accessibility_mode()) {
 380   for (size_t i = 0; i < g_created_callbacks.Get().size(); i++)
 381     g_created_callbacks.Get().at(i).Run(this);
 382   frame_tree_.SetFrameRemoveListener(
 383       base::Bind(&WebContentsImpl::OnFrameRemoved,
 384                  base::Unretained(this)));
 385 }
 386
 387 WebContentsImpl::~WebContentsImpl() {
 388   is_being_destroyed_ = true;
 389
 390   // Delete all RFH pending shutdown, which will lead the corresponding RVH to
 391   // shutdown and be deleted as well.
 392   frame_tree_.ForEach(
 393       base::Bind(&RenderFrameHostManager::ClearRFHsPendingShutdown));
 394
 395   ClearAllPowerSaveBlockers();
 396
 397   for (std::set<RenderWidgetHostImpl*>::iterator iter =
 398            created_widgets_.begin(); iter != created_widgets_.end(); ++iter) {
 399     (*iter)->DetachDelegate();
 400   }
 401   created_widgets_.clear();
 402
 403   // Clear out any JavaScript state.
 404   if (dialog_manager_)
 405     dialog_manager_->WebContentsDestroyed(this);
 406
 407   if (color_chooser_info_.get())
 408     color_chooser_info_->chooser->End();
 409
 410   NotifyDisconnected();
 411
 412   // Notify any observer that have a reference on this WebContents.
 413   NotificationService::current()->Notify(
 414       NOTIFICATION_WEB_CONTENTS_DESTROYED,
 415       Source<WebContents>(this),
 416       NotificationService::NoDetails());
 417
 418   // Destroy all frame tree nodes except for the root; this notifies observers.
 419   frame_tree_.ResetForMainFrameSwap();
 420   GetRenderManager()->ResetProxyHosts();
 421
 422   // Manually call the observer methods for the root frame tree node.
 423   RenderFrameHostManager* root = GetRenderManager();
 424   if (root->pending_frame_host()) {
 425     FOR_EACH_OBSERVER(WebContentsObserver,
 426                       observers_,
 427                       RenderFrameDeleted(root->pending_frame_host()));
 428   }
 429   FOR_EACH_OBSERVER(WebContentsObserver,
 430                     observers_,
 431                     RenderFrameDeleted(root->current_frame_host()));
 432
 433   if (root->pending_render_view_host()) {
 434     FOR_EACH_OBSERVER(WebContentsObserver,
 435                       observers_,
 436                       RenderViewDeleted(root->pending_render_view_host()));
 437   }
 438
 439   FOR_EACH_OBSERVER(WebContentsObserver,
 440                     observers_,
 441                     RenderViewDeleted(root->current_host()));
 442
 443   FOR_EACH_OBSERVER(WebContentsObserver,
 444                     observers_,
 445                     WebContentsDestroyed());
 446
 447   FOR_EACH_OBSERVER(WebContentsObserver,
 448                     observers_,
 449                     ResetWebContents());
 450
 451   SetDelegate(NULL);
 452
 453   STLDeleteContainerPairSecondPointers(destruction_observers_.begin(),
 454                                        destruction_observers_.end());
 455 }
 456
 457 WebContentsImpl* WebContentsImpl::CreateWithOpener(
 458     const WebContents::CreateParams& params,
 459     WebContentsImpl* opener) {
 460   TRACE_EVENT0("browser", "WebContentsImpl::CreateWithOpener");
 461   WebContentsImpl* new_contents = new WebContentsImpl(
 462       params.browser_context, params.opener_suppressed ? NULL : opener);
 463
 464   if (params.guest_delegate) {
 465     // This makes |new_contents| act as a guest.
 466     // For more info, see comment above class BrowserPluginGuest.
 467     BrowserPluginGuest::Create(new_contents, params.guest_delegate);
 468     // We are instantiating a WebContents for browser plugin. Set its subframe
 469     // bit to true.
 470     new_contents->is_subframe_ = true;
 471   }
 472   new_contents->Init(params);
 473   return new_contents;
 474 }
 475
 476 // static
 477 std::vector<WebContentsImpl*> WebContentsImpl::GetAllWebContents() {
 478   std::vector<WebContentsImpl*> result;
 479   scoped_ptr<RenderWidgetHostIterator> widgets(
 480       RenderWidgetHostImpl::GetRenderWidgetHosts());
 481   std::set<WebContentsImpl*> web_contents_set;
 482   while (RenderWidgetHost* rwh = widgets->GetNextHost()) {
 483     if (!rwh->IsRenderView())
 484       continue;
 485     RenderViewHost* rvh = RenderViewHost::From(rwh);
 486     if (!rvh)
 487       continue;
 488     WebContents* web_contents = WebContents::FromRenderViewHost(rvh);
 489     if (!web_contents)
 490       continue;
 491     WebContentsImpl* wci = static_cast<WebContentsImpl*>(web_contents);
 492     if (web_contents_set.find(wci) == web_contents_set.end()) {
 493       web_contents_set.insert(wci);
 494       result.push_back(wci);
 495     }
 496   }
 497   return result;
 498 }
 499
 500 RenderFrameHostManager* WebContentsImpl::GetRenderManagerForTesting() {
 501   return GetRenderManager();
 502 }
 503
 504 bool WebContentsImpl::OnMessageReceived(RenderViewHost* render_view_host,
 505                                         const IPC::Message& message) {
 506   return OnMessageReceived(render_view_host, NULL, message);
 507 }
 508
 509 bool WebContentsImpl::OnMessageReceived(RenderViewHost* render_view_host,
 510                                         RenderFrameHost* render_frame_host,
 511                                         const IPC::Message& message) {
 512   DCHECK(render_view_host || render_frame_host);
 513   if (GetWebUI() &&
 514       static_cast<WebUIImpl*>(GetWebUI())->OnMessageReceived(message)) {
 515     return true;
 516   }
 517
 518   ObserverListBase<WebContentsObserver>::Iterator it(observers_);
 519   WebContentsObserver* observer;
 520   if (render_frame_host) {
 521     while ((observer = it.GetNext()) != NULL)
 522       if (observer->OnMessageReceived(message, render_frame_host))
 523         return true;
 524   } else {
 525     while ((observer = it.GetNext()) != NULL)
 526       if (observer->OnMessageReceived(message))
 527         return true;
 528   }
 529
 530   // Message handlers should be aware of which
 531   // RenderViewHost/RenderFrameHost sent the message, which is temporarily
 532   // stored in render_(view|frame)_message_source_.
 533   if (render_frame_host)
 534     render_frame_message_source_ = render_frame_host;
 535   else
 536     render_view_message_source_ = render_view_host;
 537
 538   bool handled = true;
 539   IPC_BEGIN_MESSAGE_MAP(WebContentsImpl, message)
 540     IPC_MESSAGE_HANDLER(FrameHostMsg_PepperPluginHung, OnPepperPluginHung)
 541     IPC_MESSAGE_HANDLER(FrameHostMsg_PluginCrashed, OnPluginCrashed)
 542     IPC_MESSAGE_HANDLER(FrameHostMsg_DomOperationResponse,
 543                         OnDomOperationResponse)
 544     IPC_MESSAGE_HANDLER(FrameHostMsg_DidChangeThemeColor,
 545                         OnThemeColorChanged)
 546     IPC_MESSAGE_HANDLER(FrameHostMsg_DidFinishDocumentLoad,
 547                         OnDocumentLoadedInFrame)
 548     IPC_MESSAGE_HANDLER(FrameHostMsg_DidFinishLoad, OnDidFinishLoad)
 549     IPC_MESSAGE_HANDLER(FrameHostMsg_DidStartLoading, OnDidStartLoading)
 550     IPC_MESSAGE_HANDLER(FrameHostMsg_DidStopLoading, OnDidStopLoading)
 551     IPC_MESSAGE_HANDLER(FrameHostMsg_DidChangeLoadProgress,
 552                         OnDidChangeLoadProgress)
 553     IPC_MESSAGE_HANDLER(FrameHostMsg_OpenColorChooser, OnOpenColorChooser)
 554     IPC_MESSAGE_HANDLER(FrameHostMsg_EndColorChooser, OnEndColorChooser)
 555     IPC_MESSAGE_HANDLER(FrameHostMsg_SetSelectedColorInColorChooser,
 556                         OnSetSelectedColorInColorChooser)
 557     IPC_MESSAGE_HANDLER(FrameHostMsg_MediaPlayingNotification,
 558                         OnMediaPlayingNotification)
 559     IPC_MESSAGE_HANDLER(FrameHostMsg_MediaPausedNotification,
 560                         OnMediaPausedNotification)
 561     IPC_MESSAGE_HANDLER(FrameHostMsg_DidFirstVisuallyNonEmptyPaint,
 562                         OnFirstVisuallyNonEmptyPaint)
 563     IPC_MESSAGE_HANDLER(ViewHostMsg_DidLoadResourceFromMemoryCache,
 564                         OnDidLoadResourceFromMemoryCache)
 565     IPC_MESSAGE_HANDLER(ViewHostMsg_DidDisplayInsecureContent,
 566                         OnDidDisplayInsecureContent)
 567     IPC_MESSAGE_HANDLER(ViewHostMsg_DidRunInsecureContent,
 568                         OnDidRunInsecureContent)
 569     IPC_MESSAGE_HANDLER(ViewHostMsg_GoToEntryAtOffset, OnGoToEntryAtOffset)
 570     IPC_MESSAGE_HANDLER(ViewHostMsg_UpdateZoomLimits, OnUpdateZoomLimits)
 571     IPC_MESSAGE_HANDLER(ViewHostMsg_EnumerateDirectory, OnEnumerateDirectory)
 572     IPC_MESSAGE_HANDLER(ViewHostMsg_RegisterProtocolHandler,
 573                         OnRegisterProtocolHandler)
 574     IPC_MESSAGE_HANDLER(ViewHostMsg_UnregisterProtocolHandler,
 575                         OnUnregisterProtocolHandler)
 576     IPC_MESSAGE_HANDLER(ViewHostMsg_Find_Reply, OnFindReply)
 577     IPC_MESSAGE_HANDLER(ViewHostMsg_AppCacheAccessed, OnAppCacheAccessed)
 578     IPC_MESSAGE_HANDLER(ViewHostMsg_WebUISend, OnWebUISend)
 579     IPC_MESSAGE_HANDLER(ViewHostMsg_RequestPpapiBrokerPermission,
 580                         OnRequestPpapiBrokerPermission)
 581     IPC_MESSAGE_HANDLER_GENERIC(BrowserPluginHostMsg_Attach,
 582                                 OnBrowserPluginMessage(message))
 583     IPC_MESSAGE_HANDLER(ImageHostMsg_DidDownloadImage, OnDidDownloadImage)
 584     IPC_MESSAGE_HANDLER(ViewHostMsg_UpdateFaviconURL, OnUpdateFaviconURL)
 585     IPC_MESSAGE_HANDLER(ViewHostMsg_ShowValidationMessage,
 586                         OnShowValidationMessage)
 587     IPC_MESSAGE_HANDLER(ViewHostMsg_HideValidationMessage,
 588                         OnHideValidationMessage)
 589     IPC_MESSAGE_HANDLER(ViewHostMsg_MoveValidationMessage,
 590                         OnMoveValidationMessage)
 591 #if defined(OS_ANDROID)
 592     IPC_MESSAGE_HANDLER(ViewHostMsg_FindMatchRects_Reply,
 593                         OnFindMatchRectsReply)
 594     IPC_MESSAGE_HANDLER(ViewHostMsg_OpenDateTimeDialog,
 595                         OnOpenDateTimeDialog)
 596 #endif
 597     IPC_MESSAGE_UNHANDLED(handled = false)
 598   IPC_END_MESSAGE_MAP()
 599   render_view_message_source_ = NULL;
 600   render_frame_message_source_ = NULL;
 601
 602   return handled;
 603 }
 604
 605 void WebContentsImpl::RunFileChooser(
 606     RenderViewHost* render_view_host,
 607     const FileChooserParams& params) {
 608   if (delegate_)
 609     delegate_->RunFileChooser(this, params);
 610 }
 611
 612 NavigationControllerImpl& WebContentsImpl::GetController() {
 613   return controller_;
 614 }
 615
 616 const NavigationControllerImpl& WebContentsImpl::GetController() const {
 617   return controller_;
 618 }
 619
 620 BrowserContext* WebContentsImpl::GetBrowserContext() const {
 621   return controller_.GetBrowserContext();
 622 }
 623
 624 const GURL& WebContentsImpl::GetURL() const {
 625   // We may not have a navigation entry yet.
 626   NavigationEntry* entry = controller_.GetVisibleEntry();
 627   return entry ? entry->GetVirtualURL() : GURL::EmptyGURL();
 628 }
 629
 630 const GURL& WebContentsImpl::GetVisibleURL() const {
 631   // We may not have a navigation entry yet.
 632   NavigationEntry* entry = controller_.GetVisibleEntry();
 633   return entry ? entry->GetVirtualURL() : GURL::EmptyGURL();
 634 }
 635
 636 const GURL& WebContentsImpl::GetLastCommittedURL() const {
 637   // We may not have a navigation entry yet.
 638   NavigationEntry* entry = controller_.GetLastCommittedEntry();
 639   return entry ? entry->GetVirtualURL() : GURL::EmptyGURL();
 640 }
 641
 642 WebContentsDelegate* WebContentsImpl::GetDelegate() {
 643   return delegate_;
 644 }
 645
 646 void WebContentsImpl::SetDelegate(WebContentsDelegate* delegate) {
 647   // TODO(cbentzel): remove this debugging code?
 648   if (delegate == delegate_)
 649     return;
 650   if (delegate_)
 651     delegate_->Detach(this);
 652   delegate_ = delegate;
 653   if (delegate_) {
 654     delegate_->Attach(this);
 655     // Ensure the visible RVH reflects the new delegate's preferences.
 656     if (view_)
 657       view_->SetOverscrollControllerEnabled(CanOverscrollContent());
 658   }
 659 }
 660
 661 RenderProcessHost* WebContentsImpl::GetRenderProcessHost() const {
 662   RenderViewHostImpl* host = GetRenderManager()->current_host();
 663   return host ? host->GetProcess() : NULL;
 664 }
 665
 666 RenderFrameHost* WebContentsImpl::GetMainFrame() {
 667   return frame_tree_.root()->current_frame_host();
 668 }
 669
 670 RenderFrameHost* WebContentsImpl::GetFocusedFrame() {
 671   if (!frame_tree_.GetFocusedFrame())
 672     return NULL;
 673   return frame_tree_.GetFocusedFrame()->current_frame_host();
 674 }
 675
 676 void WebContentsImpl::ForEachFrame(
 677     const base::Callback<void(RenderFrameHost*)>& on_frame) {
 678   frame_tree_.ForEach(base::Bind(&ForEachFrameInternal, on_frame));
 679 }
 680
 681 void WebContentsImpl::SendToAllFrames(IPC::Message* message) {
 682   ForEachFrame(base::Bind(&SendToAllFramesInternal, message));
 683   delete message;
 684 }
 685
 686 RenderViewHost* WebContentsImpl::GetRenderViewHost() const {
 687   return GetRenderManager()->current_host();
 688 }
 689
 690 int WebContentsImpl::GetRoutingID() const {
 691   if (!GetRenderViewHost())
 692     return MSG_ROUTING_NONE;
 693
 694   return GetRenderViewHost()->GetRoutingID();
 695 }
 696
 697 int WebContentsImpl::GetFullscreenWidgetRoutingID() const {
 698   return fullscreen_widget_routing_id_;
 699 }
 700
 701 RenderWidgetHostView* WebContentsImpl::GetRenderWidgetHostView() const {
 702   return GetRenderManager()->GetRenderWidgetHostView();
 703 }
 704
 705 RenderWidgetHostView* WebContentsImpl::GetFullscreenRenderWidgetHostView()
 706     const {
 707   RenderWidgetHost* const widget_host =
 708       RenderWidgetHostImpl::FromID(GetRenderProcessHost()->GetID(),
 709                                    GetFullscreenWidgetRoutingID());
 710   return widget_host ? widget_host->GetView() : NULL;
 711 }
 712
 713 WebContentsView* WebContentsImpl::GetView() const {
 714   return view_.get();
 715 }
 716
 717 void WebContentsImpl::SetAccessibilityMode(AccessibilityMode mode) {
 718   if (mode == accessibility_mode_)
 719     return;
 720
 721   accessibility_mode_ = mode;
 722   frame_tree_.ForEach(
 723       base::Bind(&ForEachFrameInternal,
 724                  base::Bind(&SetAccessibilityModeOnFrame, mode)));
 725   frame_tree_.ForEach(
 726       base::Bind(&ForEachPendingFrameInternal,
 727                  base::Bind(&SetAccessibilityModeOnFrame, mode)));
 728 }
 729
 730 void WebContentsImpl::AddAccessibilityMode(AccessibilityMode mode) {
 731   SetAccessibilityMode(
 732       content::AddAccessibilityModeTo(accessibility_mode_, mode));
 733 }
 734
 735 void WebContentsImpl::RemoveAccessibilityMode(AccessibilityMode mode) {
 736   SetAccessibilityMode(
 737       content::RemoveAccessibilityModeFrom(accessibility_mode_, mode));
 738 }
 739
 740 WebUI* WebContentsImpl::CreateWebUI(const GURL& url) {
 741   WebUIImpl* web_ui = new WebUIImpl(this);
 742   WebUIController* controller = WebUIControllerFactoryRegistry::GetInstance()->
 743       CreateWebUIControllerForURL(web_ui, url);
 744   if (controller) {
 745     web_ui->AddMessageHandler(new GenericHandler());
 746     web_ui->SetController(controller);
 747     return web_ui;
 748   }
 749
 750   delete web_ui;
 751   return NULL;
 752 }
 753
 754 WebUI* WebContentsImpl::GetWebUI() const {
 755   return GetRenderManager()->web_ui() ? GetRenderManager()->web_ui()
 756       : GetRenderManager()->pending_web_ui();
 757 }
 758
 759 WebUI* WebContentsImpl::GetCommittedWebUI() const {
 760   return GetRenderManager()->web_ui();
 761 }
 762
 763 void WebContentsImpl::SetUserAgentOverride(const std::string& override) {
 764   if (GetUserAgentOverride() == override)
 765     return;
 766
 767   renderer_preferences_.user_agent_override = override;
 768
 769   // Send the new override string to the renderer.
 770   RenderViewHost* host = GetRenderViewHost();
 771   if (host)
 772     host->SyncRendererPrefs();
 773
 774   // Reload the page if a load is currently in progress to avoid having
 775   // different parts of the page loaded using different user agents.
 776   NavigationEntry* entry = controller_.GetVisibleEntry();
 777   if (is_loading_ && entry != NULL && entry->GetIsOverridingUserAgent())
 778     controller_.ReloadIgnoringCache(true);
 779
 780   FOR_EACH_OBSERVER(WebContentsObserver, observers_,
 781                     UserAgentOverrideSet(override));
 782 }
 783
 784 const std::string& WebContentsImpl::GetUserAgentOverride() const {
 785   return renderer_preferences_.user_agent_override;
 786 }
 787
 788 void WebContentsImpl::EnableTreeOnlyAccessibilityMode() {
 789   AddAccessibilityMode(AccessibilityModeTreeOnly);
 790 }
 791
 792 bool WebContentsImpl::IsTreeOnlyAccessibilityModeForTesting() const {
 793   return accessibility_mode_ == AccessibilityModeTreeOnly;
 794 }
 795
 796 bool WebContentsImpl::IsFullAccessibilityModeForTesting() const {
 797   return accessibility_mode_ == AccessibilityModeComplete;
 798 }
 799
 800 #if defined(OS_WIN)
 801 void WebContentsImpl::SetParentNativeViewAccessible(
 802 gfx::NativeViewAccessible accessible_parent) {
 803   accessible_parent_ = accessible_parent;
 804   RenderFrameHostImpl* rfh = static_cast<RenderFrameHostImpl*>(GetMainFrame());
 805   if (rfh)
 806     rfh->SetParentNativeViewAccessible(accessible_parent);
 807 }
 808 #endif
 809
 810 const base::string16& WebContentsImpl::GetTitle() const {
 811   // Transient entries take precedence. They are used for interstitial pages
 812   // that are shown on top of existing pages.
 813   NavigationEntry* entry = controller_.GetTransientEntry();
 814   std::string accept_languages =
 815       GetContentClient()->browser()->GetAcceptLangs(
 816           GetBrowserContext());
 817   if (entry) {
 818     return entry->GetTitleForDisplay(accept_languages);
 819   }
 820   WebUI* our_web_ui = GetRenderManager()->pending_web_ui() ?
 821       GetRenderManager()->pending_web_ui() : GetRenderManager()->web_ui();
 822   if (our_web_ui) {
 823     // Don't override the title in view source mode.
 824     entry = controller_.GetVisibleEntry();
 825     if (!(entry && entry->IsViewSourceMode())) {
 826       // Give the Web UI the chance to override our title.
 827       const base::string16& title = our_web_ui->GetOverriddenTitle();
 828       if (!title.empty())
 829         return title;
 830     }
 831   }
 832
 833   // We use the title for the last committed entry rather than a pending
 834   // navigation entry. For example, when the user types in a URL, we want to
 835   // keep the old page's title until the new load has committed and we get a new
 836   // title.
 837   entry = controller_.GetLastCommittedEntry();
 838
 839   // We make an exception for initial navigations.
 840   if (controller_.IsInitialNavigation()) {
 841     // We only want to use the title from the visible entry in one of two cases:
 842     // 1. There's already a committed entry for an initial navigation, in which
 843     //    case we are doing a history navigation in a new tab (e.g., Ctrl+Back).
 844     // 2. The pending entry has been explicitly assigned a title to display.
 845     //
 846     // If there's no last committed entry and no assigned title, we should fall
 847     // back to |page_title_when_no_navigation_entry_| rather than showing the
 848     // URL.
 849     if (entry ||
 850         (controller_.GetVisibleEntry() &&
 851          !controller_.GetVisibleEntry()->GetTitle().empty())) {
 852       entry = controller_.GetVisibleEntry();
 853     }
 854   }
 855
 856   if (entry) {
 857     return entry->GetTitleForDisplay(accept_languages);
 858   }
 859
 860   // |page_title_when_no_navigation_entry_| is finally used
 861   // if no title cannot be retrieved.
 862   return page_title_when_no_navigation_entry_;
 863 }
 864
 865 int32 WebContentsImpl::GetMaxPageID() {
 866   return GetMaxPageIDForSiteInstance(GetSiteInstance());
 867 }
 868
 869 int32 WebContentsImpl::GetMaxPageIDForSiteInstance(
 870     SiteInstance* site_instance) {
 871   if (max_page_ids_.find(site_instance->GetId()) == max_page_ids_.end())
 872     max_page_ids_[site_instance->GetId()] = -1;
 873
 874   return max_page_ids_[site_instance->GetId()];
 875 }
 876
 877 void WebContentsImpl::UpdateMaxPageID(int32 page_id) {
 878   UpdateMaxPageIDForSiteInstance(GetSiteInstance(), page_id);
 879 }
 880
 881 void WebContentsImpl::UpdateMaxPageIDForSiteInstance(
 882     SiteInstance* site_instance, int32 page_id) {
 883   if (GetMaxPageIDForSiteInstance(site_instance) < page_id)
 884     max_page_ids_[site_instance->GetId()] = page_id;
 885 }
 886
 887 void WebContentsImpl::CopyMaxPageIDsFrom(WebContents* web_contents) {
 888   WebContentsImpl* contents = static_cast<WebContentsImpl*>(web_contents);
 889   max_page_ids_ = contents->max_page_ids_;
 890 }
 891
 892 SiteInstance* WebContentsImpl::GetSiteInstance() const {
 893   return GetRenderManager()->current_host()->GetSiteInstance();
 894 }
 895
 896 SiteInstance* WebContentsImpl::GetPendingSiteInstance() const {
 897   RenderViewHost* dest_rvh = GetRenderManager()->pending_render_view_host() ?
 898       GetRenderManager()->pending_render_view_host() :
 899       GetRenderManager()->current_host();
 900   return dest_rvh->GetSiteInstance();
 901 }
 902
 903 bool WebContentsImpl::IsLoading() const {
 904   return is_loading_;
 905 }
 906
 907 bool WebContentsImpl::IsLoadingToDifferentDocument() const {
 908   return is_loading_ && is_load_to_different_document_;
 909 }
 910
 911 bool WebContentsImpl::IsWaitingForResponse() const {
 912   return waiting_for_response_ && is_load_to_different_document_;
 913 }
 914
 915 const net::LoadStateWithParam& WebContentsImpl::GetLoadState() const {
 916   return load_state_;
 917 }
 918
 919 const base::string16& WebContentsImpl::GetLoadStateHost() const {
 920   return load_state_host_;
 921 }
 922
 923 uint64 WebContentsImpl::GetUploadSize() const {
 924   return upload_size_;
 925 }
 926
 927 uint64 WebContentsImpl::GetUploadPosition() const {
 928   return upload_position_;
 929 }
 930
 931 std::set<GURL> WebContentsImpl::GetSitesInTab() const {
 932   std::set<GURL> sites;
 933   frame_tree_.ForEach(base::Bind(&CollectSites,
 934                                  base::Unretained(GetBrowserContext()),
 935                                  base::Unretained(&sites)));
 936   return sites;
 937 }
 938
 939 const std::string& WebContentsImpl::GetEncoding() const {
 940   return canonical_encoding_;
 941 }
 942
 943 bool WebContentsImpl::DisplayedInsecureContent() const {
 944   return displayed_insecure_content_;
 945 }
 946
 947 void WebContentsImpl::IncrementCapturerCount(const gfx::Size& capture_size) {
 948   DCHECK(!is_being_destroyed_);
 949   ++capturer_count_;
 950   DVLOG(1) << "There are now " << capturer_count_
 951            << " capturing(s) of WebContentsImpl@" << this;
 952
 953   // Note: This provides a hint to upstream code to size the views optimally
 954   // for quality (e.g., to avoid scaling).
 955   if (!capture_size.IsEmpty() && preferred_size_for_capture_.IsEmpty()) {
 956     preferred_size_for_capture_ = capture_size;
 957     OnPreferredSizeChanged(preferred_size_);
 958   }
 959 }
 960
 961 void WebContentsImpl::DecrementCapturerCount() {
 962   --capturer_count_;
 963   DVLOG(1) << "There are now " << capturer_count_
 964            << " capturing(s) of WebContentsImpl@" << this;
 965   DCHECK_LE(0, capturer_count_);
 966
 967   if (is_being_destroyed_)
 968     return;
 969
 970   if (capturer_count_ == 0) {
 971     const gfx::Size old_size = preferred_size_for_capture_;
 972     preferred_size_for_capture_ = gfx::Size();
 973     OnPreferredSizeChanged(old_size);
 974   }
 975
 976   if (IsHidden()) {
 977     DVLOG(1) << "Executing delayed WasHidden().";
 978     WasHidden();
 979   }
 980 }
 981
 982 int WebContentsImpl::GetCapturerCount() const {
 983   return capturer_count_;
 984 }
 985
 986 bool WebContentsImpl::IsCrashed() const {
 987   return (crashed_status_ == base::TERMINATION_STATUS_PROCESS_CRASHED ||
 988           crashed_status_ == base::TERMINATION_STATUS_ABNORMAL_TERMINATION ||
 989           crashed_status_ == base::TERMINATION_STATUS_PROCESS_WAS_KILLED);
 990 }
 991
 992 void WebContentsImpl::SetIsCrashed(base::TerminationStatus status,
 993                                    int error_code) {
 994   if (status == crashed_status_)
 995     return;
 996
 997   crashed_status_ = status;
 998   crashed_error_code_ = error_code;
 999   NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
1000 }
1001
1002 base::TerminationStatus WebContentsImpl::GetCrashedStatus() const {
1003   return crashed_status_;
1004 }
1005
1006 bool WebContentsImpl::IsBeingDestroyed() const {
1007   return is_being_destroyed_;
1008 }
1009
1010 void WebContentsImpl::NotifyNavigationStateChanged(
1011     InvalidateTypes changed_flags) {
1012   if (delegate_)
1013     delegate_->NavigationStateChanged(this, changed_flags);
1014 }
1015
1016 base::TimeTicks WebContentsImpl::GetLastActiveTime() const {
1017   return last_active_time_;
1018 }
1019
1020 void WebContentsImpl::WasShown() {
1021   controller_.SetActive(true);
1022
1023   std::set<RenderWidgetHostView*> widgets = GetRenderWidgetHostViewsInTree();
1024   for (std::set<RenderWidgetHostView*>::iterator iter = widgets.begin();
1025        iter != widgets.end();
1026        iter++) {
1027     if (*iter) {
1028       (*iter)->Show();
1029 #if defined(OS_MACOSX)
1030       (*iter)->SetActive(true);
1031 #endif
1032     }
1033   }
1034
1035   last_active_time_ = base::TimeTicks::Now();
1036
1037   // The resize rect might have changed while this was inactive -- send the new
1038   // one to make sure it's up to date.
1039   RenderViewHostImpl* rvh =
1040       static_cast<RenderViewHostImpl*>(GetRenderViewHost());
1041   if (rvh) {
1042     rvh->ResizeRectChanged(GetRootWindowResizerRect());
1043   }
1044
1045   FOR_EACH_OBSERVER(WebContentsObserver, observers_, WasShown());
1046
1047   should_normally_be_visible_ = true;
1048 }
1049
1050 void WebContentsImpl::WasHidden() {
1051   // If there are entities capturing screenshots or video (e.g., mirroring),
1052   // don't activate the "disable rendering" optimization.
1053   if (capturer_count_ == 0) {
1054     // |GetRenderViewHost()| can be NULL if the user middle clicks a link to
1055     // open a tab in the background, then closes the tab before selecting it.
1056     // This is because closing the tab calls WebContentsImpl::Destroy(), which
1057     // removes the |GetRenderViewHost()|; then when we actually destroy the
1058     // window, OnWindowPosChanged() notices and calls WasHidden() (which
1059     // calls us).
1060     std::set<RenderWidgetHostView*> widgets = GetRenderWidgetHostViewsInTree();
1061     for (std::set<RenderWidgetHostView*>::iterator iter = widgets.begin();
1062          iter != widgets.end();
1063          iter++) {
1064       if (*iter)
1065         (*iter)->Hide();
1066     }
1067   }
1068
1069   FOR_EACH_OBSERVER(WebContentsObserver, observers_, WasHidden());
1070
1071   should_normally_be_visible_ = false;
1072 }
1073
1074 bool WebContentsImpl::NeedToFireBeforeUnload() {
1075   // TODO(creis): Should we fire even for interstitial pages?
1076   return WillNotifyDisconnection() &&
1077       !ShowingInterstitialPage() &&
1078       !static_cast<RenderViewHostImpl*>(
1079           GetRenderViewHost())->SuddenTerminationAllowed();
1080 }
1081
1082 void WebContentsImpl::DispatchBeforeUnload(bool for_cross_site_transition) {
1083   static_cast<RenderFrameHostImpl*>(GetMainFrame())->DispatchBeforeUnload(
1084       for_cross_site_transition);
1085 }
1086
1087 void WebContentsImpl::Stop() {
1088   GetRenderManager()->Stop();
1089   FOR_EACH_OBSERVER(WebContentsObserver, observers_, NavigationStopped());
1090 }
1091
1092 WebContents* WebContentsImpl::Clone() {
1093   // We use our current SiteInstance since the cloned entry will use it anyway.
1094   // We pass our own opener so that the cloned page can access it if it was
1095   // before.
1096   CreateParams create_params(GetBrowserContext(), GetSiteInstance());
1097   create_params.initial_size = GetContainerBounds().size();
1098   WebContentsImpl* tc = CreateWithOpener(create_params, opener_);
1099   tc->GetController().CopyStateFrom(controller_);
1100   FOR_EACH_OBSERVER(WebContentsObserver,
1101                     observers_,
1102                     DidCloneToNewWebContents(this, tc));
1103   return tc;
1104 }
1105
1106 void WebContentsImpl::Observe(int type,
1107                               const NotificationSource& source,
1108                               const NotificationDetails& details) {
1109   switch (type) {
1110     case NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED: {
1111       RenderWidgetHost* host = Source<RenderWidgetHost>(source).ptr();
1112       RenderWidgetHostView* view = host->GetView();
1113       if (view == GetFullscreenRenderWidgetHostView()) {
1114         // We cannot just call view_->RestoreFocus() here.  On some platforms,
1115         // attempting to focus the currently-invisible WebContentsView will be
1116         // flat-out ignored.  Therefore, this boolean is used to track whether
1117         // we will request focus after the fullscreen widget has been
1118         // destroyed.
1119         fullscreen_widget_had_focus_at_shutdown_ = (view && view->HasFocus());
1120       } else {
1121         for (PendingWidgetViews::iterator i = pending_widget_views_.begin();
1122              i != pending_widget_views_.end(); ++i) {
1123           if (host->GetView() == i->second) {
1124             pending_widget_views_.erase(i);
1125             break;
1126           }
1127         }
1128       }
1129       break;
1130     }
1131     default:
1132       NOTREACHED();
1133   }
1134 }
1135
1136 WebContents* WebContentsImpl::GetWebContents() {
1137   return this;
1138 }
1139
1140 void WebContentsImpl::Init(const WebContents::CreateParams& params) {
1141   // This is set before initializing the render manager since
1142   // RenderFrameHostManager::Init calls back into us via its delegate to ask if
1143   // it should be hidden.
1144   should_normally_be_visible_ = !params.initially_hidden;
1145
1146   GetRenderManager()->Init(
1147       params.browser_context, params.site_instance, params.routing_id,
1148       params.main_frame_routing_id);
1149
1150   WebContentsViewDelegate* delegate =
1151       GetContentClient()->browser()->GetWebContentsViewDelegate(this);
1152
1153   if (browser_plugin_guest_) {
1154     scoped_ptr<WebContentsView> platform_view(CreateWebContentsView(
1155         this, delegate, &render_view_host_delegate_view_));
1156
1157     WebContentsViewGuest* rv = new WebContentsViewGuest(
1158         this, browser_plugin_guest_.get(), platform_view.Pass(),
1159         render_view_host_delegate_view_);
1160     render_view_host_delegate_view_ = rv;
1161     view_.reset(rv);
1162   } else {
1163     // Regular WebContentsView.
1164     view_.reset(CreateWebContentsView(
1165         this, delegate, &render_view_host_delegate_view_));
1166   }
1167   CHECK(render_view_host_delegate_view_);
1168   CHECK(view_.get());
1169
1170   gfx::Size initial_size = params.initial_size;
1171   view_->CreateView(initial_size, params.context);
1172
1173   // Listen for whether our opener gets destroyed.
1174   if (opener_)
1175     AddDestructionObserver(opener_);
1176
1177   registrar_.Add(this,
1178                  NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED,
1179                  NotificationService::AllBrowserContextsAndSources());
1180
1181   geolocation_dispatcher_host_.reset(new GeolocationDispatcherHost(this));
1182   midi_dispatcher_host_.reset(new MidiDispatcherHost(this));
1183
1184   screen_orientation_dispatcher_host_.reset(
1185       new ScreenOrientationDispatcherHost(this));
1186
1187 #if defined(OS_ANDROID)
1188   date_time_chooser_.reset(new DateTimeChooserAndroid());
1189 #endif
1190 }
1191
1192 void WebContentsImpl::OnWebContentsDestroyed(WebContentsImpl* web_contents) {
1193   RemoveDestructionObserver(web_contents);
1194
1195   // Clear the opener if it has been closed.
1196   if (web_contents == opener_) {
1197     opener_ = NULL;
1198     return;
1199   }
1200   // Clear a pending contents that has been closed before being shown.
1201   for (PendingContents::iterator iter = pending_contents_.begin();
1202        iter != pending_contents_.end();
1203        ++iter) {
1204     if (iter->second != web_contents)
1205       continue;
1206     pending_contents_.erase(iter);
1207     return;
1208   }
1209   NOTREACHED();
1210 }
1211
1212 void WebContentsImpl::AddDestructionObserver(WebContentsImpl* web_contents) {
1213   if (!ContainsKey(destruction_observers_, web_contents)) {
1214     destruction_observers_[web_contents] =
1215         new DestructionObserver(this, web_contents);
1216   }
1217 }
1218
1219 void WebContentsImpl::RemoveDestructionObserver(WebContentsImpl* web_contents) {
1220   DestructionObservers::iterator iter =
1221       destruction_observers_.find(web_contents);
1222   if (iter != destruction_observers_.end()) {
1223     delete destruction_observers_[web_contents];
1224     destruction_observers_.erase(iter);
1225   }
1226 }
1227
1228 void WebContentsImpl::AddObserver(WebContentsObserver* observer) {
1229   observers_.AddObserver(observer);
1230 }
1231
1232 void WebContentsImpl::RemoveObserver(WebContentsObserver* observer) {
1233   observers_.RemoveObserver(observer);
1234 }
1235
1236 std::set<RenderWidgetHostView*>
1237 WebContentsImpl::GetRenderWidgetHostViewsInTree() {
1238   std::set<RenderWidgetHostView*> set;
1239   if (ShowingInterstitialPage()) {
1240     set.insert(GetRenderWidgetHostView());
1241   } else {
1242     ForEachFrame(
1243         base::Bind(&AddRenderWidgetHostViewToSet, base::Unretained(&set)));
1244   }
1245   return set;
1246 }
1247
1248 void WebContentsImpl::Activate() {
1249   if (delegate_)
1250     delegate_->ActivateContents(this);
1251 }
1252
1253 void WebContentsImpl::Deactivate() {
1254   if (delegate_)
1255     delegate_->DeactivateContents(this);
1256 }
1257
1258 void WebContentsImpl::LostCapture() {
1259   if (delegate_)
1260     delegate_->LostCapture();
1261 }
1262
1263 void WebContentsImpl::RenderWidgetDeleted(
1264     RenderWidgetHostImpl* render_widget_host) {
1265   if (is_being_destroyed_) {
1266     // |created_widgets_| might have been destroyed.
1267     return;
1268   }
1269
1270   std::set<RenderWidgetHostImpl*>::iterator iter =
1271       created_widgets_.find(render_widget_host);
1272   if (iter != created_widgets_.end())
1273     created_widgets_.erase(iter);
1274
1275   if (render_widget_host &&
1276       render_widget_host->GetRoutingID() == fullscreen_widget_routing_id_) {
1277     if (delegate_ && delegate_->EmbedsFullscreenWidget())
1278       delegate_->ToggleFullscreenModeForTab(this, false);
1279     FOR_EACH_OBSERVER(WebContentsObserver,
1280                       observers_,
1281                       DidDestroyFullscreenWidget(
1282                           fullscreen_widget_routing_id_));
1283     fullscreen_widget_routing_id_ = MSG_ROUTING_NONE;
1284     if (fullscreen_widget_had_focus_at_shutdown_)
1285       view_->RestoreFocus();
1286   }
1287 }
1288
1289 bool WebContentsImpl::PreHandleKeyboardEvent(
1290     const NativeWebKeyboardEvent& event,
1291     bool* is_keyboard_shortcut) {
1292   return delegate_ &&
1293       delegate_->PreHandleKeyboardEvent(this, event, is_keyboard_shortcut);
1294 }
1295
1296 void WebContentsImpl::HandleKeyboardEvent(const NativeWebKeyboardEvent& event) {
1297   if (browser_plugin_embedder_ &&
1298       browser_plugin_embedder_->HandleKeyboardEvent(event)) {
1299     return;
1300   }
1301   if (delegate_)
1302     delegate_->HandleKeyboardEvent(this, event);
1303 }
1304
1305 bool WebContentsImpl::HandleWheelEvent(
1306     const blink::WebMouseWheelEvent& event) {
1307 #if !defined(OS_MACOSX)
1308   // On platforms other than Mac, control+mousewheel changes zoom. On Mac, this
1309   // isn't done for two reasons:
1310   //   -the OS already has a gesture to do this through pinch-zoom
1311   //   -if a user starts an inertial scroll, let's go, and presses control
1312   //      (i.e. control+tab) then the OS's buffered scroll events will come in
1313   //      with control key set which isn't what the user wants
1314   if (delegate_ &&
1315       event.wheelTicksY &&
1316       (event.modifiers & blink::WebInputEvent::ControlKey) &&
1317       // Avoid adjusting the zoom in response to two-finger-scrolling touchpad
1318       // gestures, which are regrettably easy to trigger accidentally.
1319       !event.hasPreciseScrollingDeltas) {
1320     delegate_->ContentsZoomChange(event.wheelTicksY > 0);
1321     return true;
1322   }
1323 #endif
1324   return false;
1325 }
1326
1327 bool WebContentsImpl::PreHandleGestureEvent(
1328     const blink::WebGestureEvent& event) {
1329   return delegate_ && delegate_->PreHandleGestureEvent(this, event);
1330 }
1331
1332 bool WebContentsImpl::HandleGestureEvent(
1333     const blink::WebGestureEvent& event) {
1334   // Some platforms (eg. Mac) send GesturePinch events for trackpad pinch-zoom.
1335   // Use them to implement browser zoom, as for HandleWheelEvent above.
1336   if (event.type == blink::WebInputEvent::GesturePinchUpdate &&
1337       event.sourceDevice == blink::WebGestureDeviceTouchpad) {
1338     // The scale difference necessary to trigger a zoom action. Derived from
1339     // experimentation to find a value that feels reasonable.
1340     const float kZoomStepValue = 0.6f;
1341
1342     // Find the (absolute) thresholds on either side of the current zoom factor,
1343     // then convert those to actual numbers to trigger a zoom in or out.
1344     // This logic deliberately makes the range around the starting zoom value
1345     // for the gesture twice as large as the other ranges (i.e., the notches are
1346     // at ..., -3*step, -2*step, -step, step, 2*step, 3*step, ... but not at 0)
1347     // so that it's easier to get back to your starting point than it is to
1348     // overshoot.
1349     float nextStep = (abs(currentPinchZoomStepDelta_) + 1) * kZoomStepValue;
1350     float backStep = abs(currentPinchZoomStepDelta_) * kZoomStepValue;
1351     float zoomInThreshold = (currentPinchZoomStepDelta_ >= 0) ? nextStep
1352         : -backStep;
1353     float zoomOutThreshold = (currentPinchZoomStepDelta_ <= 0) ? -nextStep
1354         : backStep;
1355
1356     totalPinchGestureAmount_ += (event.data.pinchUpdate.scale - 1.0);
1357     if (totalPinchGestureAmount_ > zoomInThreshold) {
1358       currentPinchZoomStepDelta_++;
1359       if (delegate_)
1360         delegate_->ContentsZoomChange(true);
1361     } else if (totalPinchGestureAmount_ < zoomOutThreshold) {
1362       currentPinchZoomStepDelta_--;
1363       if (delegate_)
1364         delegate_->ContentsZoomChange(false);
1365     }
1366     return true;
1367   }
1368
1369   return false;
1370 }
1371
1372 void WebContentsImpl::HandleMouseDown() {
1373   if (delegate_)
1374     delegate_->HandleMouseDown();
1375 }
1376
1377 void WebContentsImpl::HandleMouseUp() {
1378   if (delegate_)
1379     delegate_->HandleMouseUp();
1380 }
1381
1382 void WebContentsImpl::HandlePointerActivate() {
1383   if (delegate_)
1384     delegate_->HandlePointerActivate();
1385 }
1386
1387 void WebContentsImpl::HandleGestureBegin() {
1388   if (delegate_)
1389     delegate_->HandleGestureBegin();
1390 }
1391
1392 void WebContentsImpl::HandleGestureEnd() {
1393   if (delegate_)
1394     delegate_->HandleGestureEnd();
1395 }
1396
1397 void WebContentsImpl::ToggleFullscreenMode(bool enter_fullscreen) {
1398   // This method is being called to enter or leave renderer-initiated fullscreen
1399   // mode.  Either way, make sure any existing fullscreen widget is shut down
1400   // first.
1401   RenderWidgetHostView* const widget_view = GetFullscreenRenderWidgetHostView();
1402   if (widget_view)
1403     RenderWidgetHostImpl::From(widget_view->GetRenderWidgetHost())->Shutdown();
1404
1405   if (delegate_)
1406     delegate_->ToggleFullscreenModeForTab(this, enter_fullscreen);
1407
1408   FOR_EACH_OBSERVER(WebContentsObserver,
1409                     observers_,
1410                     DidToggleFullscreenModeForTab(IsFullscreenForCurrentTab()));
1411 }
1412
1413 bool WebContentsImpl::IsFullscreenForCurrentTab() const {
1414   return delegate_ ? delegate_->IsFullscreenForTabOrPending(this) : false;
1415 }
1416
1417 void WebContentsImpl::RequestToLockMouse(bool user_gesture,
1418                                          bool last_unlocked_by_target) {
1419   if (delegate_) {
1420     delegate_->RequestToLockMouse(this, user_gesture, last_unlocked_by_target);
1421   } else {
1422     GotResponseToLockMouseRequest(false);
1423   }
1424 }
1425
1426 void WebContentsImpl::LostMouseLock() {
1427   if (delegate_)
1428     delegate_->LostMouseLock();
1429 }
1430
1431 void WebContentsImpl::CreateNewWindow(
1432     int render_process_id,
1433     int route_id,
1434     int main_frame_route_id,
1435     const ViewHostMsg_CreateWindow_Params& params,
1436     SessionStorageNamespace* session_storage_namespace) {
1437   // We usually create the new window in the same BrowsingInstance (group of
1438   // script-related windows), by passing in the current SiteInstance.  However,
1439   // if the opener is being suppressed (in a non-guest), we create a new
1440   // SiteInstance in its own BrowsingInstance.
1441   bool is_guest = BrowserPluginGuest::IsGuest(this);
1442
1443   // If the opener is to be suppressed, the new window can be in any process.
1444   // Since routing ids are process specific, we must not have one passed in
1445   // as argument here.
1446   DCHECK(!params.opener_suppressed || route_id == MSG_ROUTING_NONE);
1447
1448   scoped_refptr<SiteInstance> site_instance =
1449       params.opener_suppressed && !is_guest ?
1450       SiteInstance::CreateForURL(GetBrowserContext(), params.target_url) :
1451       GetSiteInstance();
1452
1453   // A message to create a new window can only come from the active process for
1454   // this WebContentsImpl instance. If any other process sends the request,
1455   // it is invalid and the process must be terminated.
1456   if (GetRenderProcessHost()->GetID() != render_process_id) {
1457     base::ProcessHandle process_handle =
1458         RenderProcessHost::FromID(render_process_id)->GetHandle();
1459     if (process_handle != base::kNullProcessHandle) {
1460       RecordAction(
1461           base::UserMetricsAction("Terminate_ProcessMismatch_CreateNewWindow"));
1462       base::KillProcess(process_handle, content::RESULT_CODE_KILLED, false);
1463     }
1464     return;
1465   }
1466
1467   // We must assign the SessionStorageNamespace before calling Init().
1468   //
1469   // http://crbug.com/142685
1470   const std::string& partition_id =
1471       GetContentClient()->browser()->
1472           GetStoragePartitionIdForSite(GetBrowserContext(),
1473                                        site_instance->GetSiteURL());
1474   StoragePartition* partition = BrowserContext::GetStoragePartition(
1475       GetBrowserContext(), site_instance.get());
1476   DOMStorageContextWrapper* dom_storage_context =
1477       static_cast<DOMStorageContextWrapper*>(partition->GetDOMStorageContext());
1478   SessionStorageNamespaceImpl* session_storage_namespace_impl =
1479       static_cast<SessionStorageNamespaceImpl*>(session_storage_namespace);
1480   CHECK(session_storage_namespace_impl->IsFromContext(dom_storage_context));
1481
1482   if (delegate_ &&
1483       !delegate_->ShouldCreateWebContents(this,
1484                                           route_id,
1485                                           params.window_container_type,
1486                                           params.frame_name,
1487                                           params.target_url,
1488                                           partition_id,
1489                                           session_storage_namespace)) {
1490     if (route_id != MSG_ROUTING_NONE &&
1491         !RenderViewHost::FromID(render_process_id, route_id)) {
1492       // If the embedder didn't create a WebContents for this route, we need to
1493       // delete the RenderView that had already been created.
1494       Send(new ViewMsg_Close(route_id));
1495     }
1496     GetRenderViewHost()->GetProcess()->ResumeRequestsForView(route_id);
1497     GetRenderViewHost()->GetProcess()->ResumeRequestsForView(
1498         main_frame_route_id);
1499     return;
1500   }
1501
1502   // Create the new web contents. This will automatically create the new
1503   // WebContentsView. In the future, we may want to create the view separately.
1504   CreateParams create_params(GetBrowserContext(), site_instance.get());
1505   create_params.routing_id = route_id;
1506   create_params.main_frame_routing_id = main_frame_route_id;
1507   create_params.opener = this;
1508   create_params.opener_suppressed = params.opener_suppressed;
1509   if (params.disposition == NEW_BACKGROUND_TAB)
1510     create_params.initially_hidden = true;
1511
1512   WebContentsImpl* new_contents = NULL;
1513   if (!is_guest) {
1514     create_params.context = view_->GetNativeView();
1515     create_params.initial_size = GetContainerBounds().size();
1516     new_contents = static_cast<WebContentsImpl*>(
1517         WebContents::Create(create_params));
1518   }  else {
1519     new_contents = GetBrowserPluginGuest()->CreateNewGuestWindow(create_params);
1520   }
1521   new_contents->GetController().SetSessionStorageNamespace(
1522       partition_id,
1523       session_storage_namespace);
1524   new_contents->RenderViewCreated(new_contents->GetRenderViewHost());
1525
1526   // Save the window for later if we're not suppressing the opener (since it
1527   // will be shown immediately).
1528   if (!params.opener_suppressed) {
1529     if (!is_guest) {
1530       WebContentsView* new_view = new_contents->view_.get();
1531
1532       // TODO(brettw): It seems bogus that we have to call this function on the
1533       // newly created object and give it one of its own member variables.
1534       new_view->CreateViewForWidget(new_contents->GetRenderViewHost());
1535     }
1536     // Save the created window associated with the route so we can show it
1537     // later.
1538     DCHECK_NE(MSG_ROUTING_NONE, route_id);
1539     pending_contents_[route_id] = new_contents;
1540     AddDestructionObserver(new_contents);
1541   }
1542
1543   if (delegate_) {
1544     delegate_->WebContentsCreated(
1545         this, params.opener_render_frame_id, params.frame_name,
1546         params.target_url, new_contents);
1547   }
1548
1549   if (params.opener_suppressed) {
1550     // When the opener is suppressed, the original renderer cannot access the
1551     // new window.  As a result, we need to show and navigate the window here.
1552     bool was_blocked = false;
1553     if (delegate_) {
1554       gfx::Rect initial_pos;
1555       delegate_->AddNewContents(
1556           this, new_contents, params.disposition, initial_pos,
1557           params.user_gesture, &was_blocked);
1558     }
1559     if (!was_blocked) {
1560       OpenURLParams open_params(params.target_url,
1561                                 Referrer(),
1562                                 CURRENT_TAB,
1563                                 PAGE_TRANSITION_LINK,
1564                                 true /* is_renderer_initiated */);
1565       open_params.user_gesture = params.user_gesture;
1566       new_contents->OpenURL(open_params);
1567     }
1568   }
1569 }
1570
1571 void WebContentsImpl::CreateNewWidget(int render_process_id,
1572                                       int route_id,
1573                                       blink::WebPopupType popup_type) {
1574   CreateNewWidget(render_process_id, route_id, false, popup_type);
1575 }
1576
1577 void WebContentsImpl::CreateNewFullscreenWidget(int render_process_id,
1578                                                 int route_id) {
1579   CreateNewWidget(render_process_id, route_id, true, blink::WebPopupTypeNone);
1580 }
1581
1582 void WebContentsImpl::CreateNewWidget(int render_process_id,
1583                                       int route_id,
1584                                       bool is_fullscreen,
1585                                       blink::WebPopupType popup_type) {
1586   RenderProcessHost* process = GetRenderProcessHost();
1587   // A message to create a new widget can only come from the active process for
1588   // this WebContentsImpl instance. If any other process sends the request,
1589   // it is invalid and the process must be terminated.
1590   if (process->GetID() != render_process_id) {
1591     base::ProcessHandle process_handle =
1592         RenderProcessHost::FromID(render_process_id)->GetHandle();
1593     if (process_handle != base::kNullProcessHandle) {
1594       RecordAction(
1595           base::UserMetricsAction("Terminate_ProcessMismatch_CreateNewWidget"));
1596       base::KillProcess(process_handle, content::RESULT_CODE_KILLED, false);
1597     }
1598     return;
1599   }
1600
1601   RenderWidgetHostImpl* widget_host =
1602       new RenderWidgetHostImpl(this, process, route_id, IsHidden());
1603   created_widgets_.insert(widget_host);
1604
1605   RenderWidgetHostViewBase* widget_view =
1606       static_cast<RenderWidgetHostViewBase*>(
1607           view_->CreateViewForPopupWidget(widget_host));
1608   if (!widget_view)
1609     return;
1610   if (!is_fullscreen) {
1611     // Popups should not get activated.
1612     widget_view->SetPopupType(popup_type);
1613   }
1614   // Save the created widget associated with the route so we can show it later.
1615   pending_widget_views_[route_id] = widget_view;
1616
1617 #if defined(OS_MACOSX)
1618   // A RenderWidgetHostViewMac has lifetime scoped to the view. We'll retain it
1619   // to allow it to survive the trip without being hosted.
1620   base::mac::NSObjectRetain(widget_view->GetNativeView());
1621 #endif
1622 }
1623
1624 void WebContentsImpl::ShowCreatedWindow(int route_id,
1625                                         WindowOpenDisposition disposition,
1626                                         const gfx::Rect& initial_pos,
1627                                         bool user_gesture) {
1628   WebContentsImpl* contents = GetCreatedWindow(route_id);
1629   if (contents) {
1630     WebContentsDelegate* delegate = GetDelegate();
1631     if (delegate) {
1632       delegate->AddNewContents(
1633           this, contents, disposition, initial_pos, user_gesture, NULL);
1634     }
1635   }
1636 }
1637
1638 void WebContentsImpl::ShowCreatedWidget(int route_id,
1639                                         const gfx::Rect& initial_pos) {
1640   ShowCreatedWidget(route_id, false, initial_pos);
1641 }
1642
1643 void WebContentsImpl::ShowCreatedFullscreenWidget(int route_id) {
1644   ShowCreatedWidget(route_id, true, gfx::Rect());
1645 }
1646
1647 void WebContentsImpl::ShowCreatedWidget(int route_id,
1648                                         bool is_fullscreen,
1649                                         const gfx::Rect& initial_pos) {
1650   RenderWidgetHostViewBase* widget_host_view =
1651       static_cast<RenderWidgetHostViewBase*>(GetCreatedWidget(route_id));
1652   if (!widget_host_view)
1653     return;
1654
1655   RenderWidgetHostView* view = NULL;
1656   BrowserPluginGuest* guest = GetBrowserPluginGuest();
1657   if (guest && guest->embedder_web_contents()) {
1658     view = guest->embedder_web_contents()->GetRenderWidgetHostView();
1659   } else {
1660     view = GetRenderWidgetHostView();
1661   }
1662
1663   if (is_fullscreen) {
1664     DCHECK_EQ(MSG_ROUTING_NONE, fullscreen_widget_routing_id_);
1665     view_->StoreFocus();
1666     fullscreen_widget_routing_id_ = route_id;
1667     if (delegate_ && delegate_->EmbedsFullscreenWidget()) {
1668       widget_host_view->InitAsChild(GetRenderWidgetHostView()->GetNativeView());
1669       delegate_->ToggleFullscreenModeForTab(this, true);
1670     } else {
1671       widget_host_view->InitAsFullscreen(view);
1672     }
1673     FOR_EACH_OBSERVER(WebContentsObserver,
1674                       observers_,
1675                       DidShowFullscreenWidget(route_id));
1676     if (!widget_host_view->HasFocus())
1677       widget_host_view->Focus();
1678   } else {
1679     widget_host_view->InitAsPopup(view, initial_pos);
1680   }
1681
1682   RenderWidgetHostImpl* render_widget_host_impl =
1683       RenderWidgetHostImpl::From(widget_host_view->GetRenderWidgetHost());
1684   render_widget_host_impl->Init();
1685   // Only allow privileged mouse lock for fullscreen render widget, which is
1686   // used to implement Pepper Flash fullscreen.
1687   render_widget_host_impl->set_allow_privileged_mouse_lock(is_fullscreen);
1688
1689 #if defined(OS_MACOSX)
1690   // A RenderWidgetHostViewMac has lifetime scoped to the view. Now that it's
1691   // properly embedded (or purposefully ignored) we can release the retain we
1692   // took in CreateNewWidget().
1693   base::mac::NSObjectRelease(widget_host_view->GetNativeView());
1694 #endif
1695 }
1696
1697 WebContentsImpl* WebContentsImpl::GetCreatedWindow(int route_id) {
1698   PendingContents::iterator iter = pending_contents_.find(route_id);
1699
1700   // Certain systems can block the creation of new windows. If we didn't succeed
1701   // in creating one, just return NULL.
1702   if (iter == pending_contents_.end()) {
1703     return NULL;
1704   }
1705
1706   WebContentsImpl* new_contents = iter->second;
1707   pending_contents_.erase(route_id);
1708   RemoveDestructionObserver(new_contents);
1709
1710   // Don't initialize the guest WebContents immediately.
1711   if (BrowserPluginGuest::IsGuest(new_contents))
1712     return new_contents;
1713
1714   if (!new_contents->GetRenderProcessHost()->HasConnection() ||
1715       !new_contents->GetRenderViewHost()->GetView())
1716     return NULL;
1717
1718   // TODO(brettw): It seems bogus to reach into here and initialize the host.
1719   static_cast<RenderViewHostImpl*>(new_contents->GetRenderViewHost())->Init();
1720   return new_contents;
1721 }
1722
1723 RenderWidgetHostView* WebContentsImpl::GetCreatedWidget(int route_id) {
1724   PendingWidgetViews::iterator iter = pending_widget_views_.find(route_id);
1725   if (iter == pending_widget_views_.end()) {
1726     DCHECK(false);
1727     return NULL;
1728   }
1729
1730   RenderWidgetHostView* widget_host_view = iter->second;
1731   pending_widget_views_.erase(route_id);
1732
1733   RenderWidgetHost* widget_host = widget_host_view->GetRenderWidgetHost();
1734   if (!widget_host->GetProcess()->HasConnection()) {
1735     // The view has gone away or the renderer crashed. Nothing to do.
1736     return NULL;
1737   }
1738
1739   return widget_host_view;
1740 }
1741
1742 void WebContentsImpl::RequestMediaAccessPermission(
1743     const MediaStreamRequest& request,
1744     const MediaResponseCallback& callback) {
1745   if (delegate_) {
1746     delegate_->RequestMediaAccessPermission(this, request, callback);
1747   } else {
1748     callback.Run(MediaStreamDevices(),
1749                  MEDIA_DEVICE_INVALID_STATE,
1750                  scoped_ptr<MediaStreamUI>());
1751   }
1752 }
1753
1754 SessionStorageNamespace* WebContentsImpl::GetSessionStorageNamespace(
1755     SiteInstance* instance) {
1756   return controller_.GetSessionStorageNamespace(instance);
1757 }
1758
1759 SessionStorageNamespaceMap WebContentsImpl::GetSessionStorageNamespaceMap() {
1760   return controller_.GetSessionStorageNamespaceMap();
1761 }
1762
1763 FrameTree* WebContentsImpl::GetFrameTree() {
1764   return &frame_tree_;
1765 }
1766
1767 AccessibilityMode WebContentsImpl::GetAccessibilityMode() const {
1768   return accessibility_mode_;
1769 }
1770
1771 void WebContentsImpl::AccessibilityEventReceived(
1772     const std::vector<AXEventNotificationDetails>& details) {
1773   FOR_EACH_OBSERVER(
1774       WebContentsObserver, observers_, AccessibilityEventReceived(details));
1775 }
1776
1777 void WebContentsImpl::OnShowValidationMessage(
1778     const gfx::Rect& anchor_in_root_view,
1779     const base::string16& main_text,
1780     const base::string16& sub_text) {
1781   if (delegate_)
1782     delegate_->ShowValidationMessage(
1783         this, anchor_in_root_view, main_text, sub_text);
1784 }
1785
1786 void WebContentsImpl::OnHideValidationMessage() {
1787   if (delegate_)
1788     delegate_->HideValidationMessage(this);
1789 }
1790
1791 void WebContentsImpl::OnMoveValidationMessage(
1792     const gfx::Rect& anchor_in_root_view) {
1793   if (delegate_)
1794     delegate_->MoveValidationMessage(this, anchor_in_root_view);
1795 }
1796
1797 void WebContentsImpl::DidSendScreenRects(RenderWidgetHostImpl* rwh) {
1798   if (browser_plugin_embedder_)
1799     browser_plugin_embedder_->DidSendScreenRects();
1800 }
1801
1802 BrowserAccessibilityManager*
1803     WebContentsImpl::GetRootBrowserAccessibilityManager() {
1804   RenderFrameHostImpl* rfh = static_cast<RenderFrameHostImpl*>(GetMainFrame());
1805   return rfh ? rfh->browser_accessibility_manager() : NULL;
1806 }
1807
1808 BrowserAccessibilityManager*
1809     WebContentsImpl::GetOrCreateRootBrowserAccessibilityManager() {
1810   RenderFrameHostImpl* rfh = static_cast<RenderFrameHostImpl*>(GetMainFrame());
1811   return rfh ? rfh->GetOrCreateBrowserAccessibilityManager() : NULL;
1812 }
1813
1814 void WebContentsImpl::UpdatePreferredSize(const gfx::Size& pref_size) {
1815   const gfx::Size old_size = GetPreferredSize();
1816   preferred_size_ = pref_size;
1817   OnPreferredSizeChanged(old_size);
1818 }
1819
1820 void WebContentsImpl::ResizeDueToAutoResize(const gfx::Size& new_size) {
1821   if (delegate_)
1822     delegate_->ResizeDueToAutoResize(this, new_size);
1823 }
1824
1825 WebContents* WebContentsImpl::OpenURL(const OpenURLParams& params) {
1826   if (!delegate_)
1827     return NULL;
1828
1829   WebContents* new_contents = delegate_->OpenURLFromTab(this, params);
1830   return new_contents;
1831 }
1832
1833 bool WebContentsImpl::Send(IPC::Message* message) {
1834   if (!GetRenderViewHost()) {
1835     delete message;
1836     return false;
1837   }
1838
1839   return GetRenderViewHost()->Send(message);
1840 }
1841
1842 bool WebContentsImpl::NavigateToPendingEntry(
1843     NavigationController::ReloadType reload_type) {
1844   FrameTreeNode* node = frame_tree_.root();
1845
1846   // If we are using --site-per-process, we should navigate in the FrameTreeNode
1847   // specified in the pending entry.
1848   NavigationEntryImpl* pending_entry =
1849       NavigationEntryImpl::FromNavigationEntry(controller_.GetPendingEntry());
1850   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kSitePerProcess) &&
1851       pending_entry->frame_tree_node_id() != -1) {
1852     node = frame_tree_.FindByID(pending_entry->frame_tree_node_id());
1853   }
1854
1855   return node->navigator()->NavigateToPendingEntry(
1856       node->current_frame_host(), reload_type);
1857 }
1858
1859 void WebContentsImpl::RenderFrameForInterstitialPageCreated(
1860     RenderFrameHost* render_frame_host) {
1861   FOR_EACH_OBSERVER(WebContentsObserver, observers_,
1862                     RenderFrameForInterstitialPageCreated(render_frame_host));
1863 }
1864
1865 void WebContentsImpl::AttachInterstitialPage(
1866     InterstitialPageImpl* interstitial_page) {
1867   DCHECK(interstitial_page);
1868   GetRenderManager()->set_interstitial_page(interstitial_page);
1869
1870   // Cancel any visible dialogs so that they don't interfere with the
1871   // interstitial.
1872   if (dialog_manager_)
1873     dialog_manager_->CancelActiveAndPendingDialogs(this);
1874
1875   FOR_EACH_OBSERVER(WebContentsObserver, observers_,
1876                     DidAttachInterstitialPage());
1877 }
1878
1879 void WebContentsImpl::DetachInterstitialPage() {
1880   if (ShowingInterstitialPage())
1881     GetRenderManager()->remove_interstitial_page();
1882   FOR_EACH_OBSERVER(WebContentsObserver, observers_,
1883                     DidDetachInterstitialPage());
1884 }
1885
1886 void WebContentsImpl::SetHistoryLengthAndPrune(
1887     const SiteInstance* site_instance,
1888     int history_length,
1889     int32 minimum_page_id) {
1890   // SetHistoryLengthAndPrune doesn't work when there are pending cross-site
1891   // navigations. Callers should ensure that this is the case.
1892   if (GetRenderManager()->pending_render_view_host()) {
1893     NOTREACHED();
1894     return;
1895   }
1896   RenderViewHostImpl* rvh = GetRenderViewHostImpl();
1897   if (!rvh) {
1898     NOTREACHED();
1899     return;
1900   }
1901   if (site_instance && rvh->GetSiteInstance() != site_instance) {
1902     NOTREACHED();
1903     return;
1904   }
1905   Send(new ViewMsg_SetHistoryLengthAndPrune(GetRoutingID(),
1906                                             history_length,
1907                                             minimum_page_id));
1908 }
1909
1910 void WebContentsImpl::ReloadFocusedFrame(bool ignore_cache) {
1911   RenderFrameHost* focused_frame = GetFocusedFrame();
1912   if (!focused_frame)
1913     return;
1914
1915   focused_frame->Send(new FrameMsg_Reload(
1916       focused_frame->GetRoutingID(), ignore_cache));
1917 }
1918
1919 void WebContentsImpl::Undo() {
1920   RenderFrameHost* focused_frame = GetFocusedFrame();
1921   if (!focused_frame)
1922     return;
1923
1924   focused_frame->Send(new InputMsg_Undo(focused_frame->GetRoutingID()));
1925   RecordAction(base::UserMetricsAction("Undo"));
1926 }
1927
1928 void WebContentsImpl::Redo() {
1929   RenderFrameHost* focused_frame = GetFocusedFrame();
1930   if (!focused_frame)
1931     return;
1932   focused_frame->Send(new InputMsg_Redo(focused_frame->GetRoutingID()));
1933   RecordAction(base::UserMetricsAction("Redo"));
1934 }
1935
1936 void WebContentsImpl::Cut() {
1937   RenderFrameHost* focused_frame = GetFocusedFrame();
1938   if (!focused_frame)
1939     return;
1940
1941   focused_frame->Send(new InputMsg_Cut(focused_frame->GetRoutingID()));
1942   RecordAction(base::UserMetricsAction("Cut"));
1943 }
1944
1945 void WebContentsImpl::Copy() {
1946   RenderFrameHost* focused_frame = GetFocusedFrame();
1947   if (!focused_frame)
1948     return;
1949
1950   focused_frame->Send(new InputMsg_Copy(focused_frame->GetRoutingID()));
1951   RecordAction(base::UserMetricsAction("Copy"));
1952 }
1953
1954 void WebContentsImpl::CopyToFindPboard() {
1955 #if defined(OS_MACOSX)
1956   RenderFrameHost* focused_frame = GetFocusedFrame();
1957   if (!focused_frame)
1958     return;
1959
1960   // Windows/Linux don't have the concept of a find pasteboard.
1961   focused_frame->Send(
1962       new InputMsg_CopyToFindPboard(focused_frame->GetRoutingID()));
1963   RecordAction(base::UserMetricsAction("CopyToFindPboard"));
1964 #endif
1965 }
1966
1967 void WebContentsImpl::Paste() {
1968   RenderFrameHost* focused_frame = GetFocusedFrame();
1969   if (!focused_frame)
1970     return;
1971
1972   focused_frame->Send(new InputMsg_Paste(focused_frame->GetRoutingID()));
1973   RecordAction(base::UserMetricsAction("Paste"));
1974 }
1975
1976 void WebContentsImpl::PasteAndMatchStyle() {
1977   RenderFrameHost* focused_frame = GetFocusedFrame();
1978   if (!focused_frame)
1979     return;
1980
1981   focused_frame->Send(new InputMsg_PasteAndMatchStyle(
1982       focused_frame->GetRoutingID()));
1983   RecordAction(base::UserMetricsAction("PasteAndMatchStyle"));
1984 }
1985
1986 void WebContentsImpl::Delete() {
1987   RenderFrameHost* focused_frame = GetFocusedFrame();
1988   if (!focused_frame)
1989     return;
1990
1991   focused_frame->Send(new InputMsg_Delete(focused_frame->GetRoutingID()));
1992   RecordAction(base::UserMetricsAction("DeleteSelection"));
1993 }
1994
1995 void WebContentsImpl::SelectAll() {
1996   RenderFrameHost* focused_frame = GetFocusedFrame();
1997   if (!focused_frame)
1998     return;
1999
2000   focused_frame->Send(new InputMsg_SelectAll(focused_frame->GetRoutingID()));
2001   RecordAction(base::UserMetricsAction("SelectAll"));
2002 }
2003
2004 void WebContentsImpl::Unselect() {
2005   RenderFrameHost* focused_frame = GetFocusedFrame();
2006   if (!focused_frame)
2007     return;
2008
2009   focused_frame->Send(new InputMsg_Unselect(focused_frame->GetRoutingID()));
2010   RecordAction(base::UserMetricsAction("Unselect"));
2011 }
2012
2013 void WebContentsImpl::Replace(const base::string16& word) {
2014   RenderFrameHost* focused_frame = GetFocusedFrame();
2015   if (!focused_frame)
2016     return;
2017
2018   focused_frame->Send(new InputMsg_Replace(
2019       focused_frame->GetRoutingID(), word));
2020 }
2021
2022 void WebContentsImpl::ReplaceMisspelling(const base::string16& word) {
2023   RenderFrameHost* focused_frame = GetFocusedFrame();
2024   if (!focused_frame)
2025     return;
2026
2027   focused_frame->Send(new InputMsg_ReplaceMisspelling(
2028       focused_frame->GetRoutingID(), word));
2029 }
2030
2031 void WebContentsImpl::NotifyContextMenuClosed(
2032     const CustomContextMenuContext& context) {
2033   RenderFrameHost* focused_frame = GetFocusedFrame();
2034   if (!focused_frame)
2035     return;
2036
2037   focused_frame->Send(new FrameMsg_ContextMenuClosed(
2038       focused_frame->GetRoutingID(), context));
2039 }
2040
2041 void WebContentsImpl::ExecuteCustomContextMenuCommand(
2042     int action, const CustomContextMenuContext& context) {
2043   RenderFrameHost* focused_frame = GetFocusedFrame();
2044   if (!focused_frame)
2045     return;
2046
2047   focused_frame->Send(new FrameMsg_CustomContextMenuAction(
2048       focused_frame->GetRoutingID(), context, action));
2049 }
2050
2051 gfx::NativeView WebContentsImpl::GetNativeView() {
2052   return view_->GetNativeView();
2053 }
2054
2055 gfx::NativeView WebContentsImpl::GetContentNativeView() {
2056   return view_->GetContentNativeView();
2057 }
2058
2059 gfx::NativeWindow WebContentsImpl::GetTopLevelNativeWindow() {
2060   return view_->GetTopLevelNativeWindow();
2061 }
2062
2063 gfx::Rect WebContentsImpl::GetViewBounds() {
2064   return view_->GetViewBounds();
2065 }
2066
2067 gfx::Rect WebContentsImpl::GetContainerBounds() {
2068   gfx::Rect rv;
2069   view_->GetContainerBounds(&rv);
2070   return rv;
2071 }
2072
2073 DropData* WebContentsImpl::GetDropData() {
2074   return view_->GetDropData();
2075 }
2076
2077 void WebContentsImpl::Focus() {
2078   RenderWidgetHostView* const fullscreen_view =
2079       GetFullscreenRenderWidgetHostView();
2080   if (fullscreen_view)
2081     fullscreen_view->Focus();
2082   else
2083     view_->Focus();
2084 }
2085
2086 void WebContentsImpl::SetInitialFocus() {
2087   RenderWidgetHostView* const fullscreen_view =
2088       GetFullscreenRenderWidgetHostView();
2089   if (fullscreen_view)
2090     fullscreen_view->Focus();
2091   else
2092     view_->SetInitialFocus();
2093 }
2094
2095 void WebContentsImpl::StoreFocus() {
2096   if (!GetFullscreenRenderWidgetHostView())
2097     view_->StoreFocus();
2098 }
2099
2100 void WebContentsImpl::RestoreFocus() {
2101   RenderWidgetHostView* const fullscreen_view =
2102       GetFullscreenRenderWidgetHostView();
2103   if (fullscreen_view)
2104     fullscreen_view->Focus();
2105   else
2106     view_->RestoreFocus();
2107 }
2108
2109 void WebContentsImpl::FocusThroughTabTraversal(bool reverse) {
2110   if (ShowingInterstitialPage()) {
2111     GetRenderManager()->interstitial_page()->FocusThroughTabTraversal(reverse);
2112     return;
2113   }
2114   RenderWidgetHostView* const fullscreen_view =
2115       GetFullscreenRenderWidgetHostView();
2116   if (fullscreen_view) {
2117     fullscreen_view->Focus();
2118     return;
2119   }
2120   GetRenderViewHostImpl()->SetInitialFocus(reverse);
2121 }
2122
2123 bool WebContentsImpl::ShowingInterstitialPage() const {
2124   return GetRenderManager()->interstitial_page() != NULL;
2125 }
2126
2127 InterstitialPage* WebContentsImpl::GetInterstitialPage() const {
2128   return GetRenderManager()->interstitial_page();
2129 }
2130
2131 bool WebContentsImpl::IsSavable() {
2132   // WebKit creates Document object when MIME type is application/xhtml+xml,
2133   // so we also support this MIME type.
2134   return contents_mime_type_ == "text/html" ||
2135          contents_mime_type_ == "text/xml" ||
2136          contents_mime_type_ == "application/xhtml+xml" ||
2137          contents_mime_type_ == "text/plain" ||
2138          contents_mime_type_ == "text/css" ||
2139          net::IsSupportedJavascriptMimeType(contents_mime_type_.c_str());
2140 }
2141
2142 void WebContentsImpl::OnSavePage() {
2143   // If we can not save the page, try to download it.
2144   if (!IsSavable()) {
2145     RecordDownloadSource(INITIATED_BY_SAVE_PACKAGE_ON_NON_HTML);
2146     SaveFrame(GetURL(), Referrer());
2147     return;
2148   }
2149
2150   Stop();
2151
2152   // Create the save package and possibly prompt the user for the name to save
2153   // the page as. The user prompt is an asynchronous operation that runs on
2154   // another thread.
2155   save_package_ = new SavePackage(this);
2156   save_package_->GetSaveInfo();
2157 }
2158
2159 // Used in automated testing to bypass prompting the user for file names.
2160 // Instead, the names and paths are hard coded rather than running them through
2161 // file name sanitation and extension / mime checking.
2162 bool WebContentsImpl::SavePage(const base::FilePath& main_file,
2163                                const base::FilePath& dir_path,
2164                                SavePageType save_type) {
2165   // Stop the page from navigating.
2166   Stop();
2167
2168   save_package_ = new SavePackage(this, save_type, main_file, dir_path);
2169   return save_package_->Init(SavePackageDownloadCreatedCallback());
2170 }
2171
2172 void WebContentsImpl::SaveFrame(const GURL& url,
2173                                 const Referrer& referrer) {
2174   if (!GetURL().is_valid())
2175     return;
2176   bool is_main_frame = (url == GetURL());
2177
2178   DownloadManager* dlm =
2179       BrowserContext::GetDownloadManager(GetBrowserContext());
2180   if (!dlm)
2181     return;
2182   int64 post_id = -1;
2183   if (is_main_frame) {
2184     const NavigationEntry* entry = controller_.GetLastCommittedEntry();
2185     if (entry)
2186       post_id = entry->GetPostID();
2187   }
2188   scoped_ptr<DownloadUrlParameters> params(
2189       DownloadUrlParameters::FromWebContents(this, url));
2190   params->set_referrer(referrer);
2191   params->set_post_id(post_id);
2192   params->set_prefer_cache(true);
2193   if (post_id >= 0)
2194     params->set_method("POST");
2195   params->set_prompt(true);
2196   dlm->DownloadUrl(params.Pass());
2197 }
2198
2199 void WebContentsImpl::GenerateMHTML(
2200     const base::FilePath& file,
2201     const base::Callback<void(int64)>& callback) {
2202   MHTMLGenerationManager::GetInstance()->SaveMHTML(this, file, callback);
2203 }
2204
2205 const std::string& WebContentsImpl::GetContentsMimeType() const {
2206   return contents_mime_type_;
2207 }
2208
2209 bool WebContentsImpl::WillNotifyDisconnection() const {
2210   return notify_disconnection_;
2211 }
2212
2213 void WebContentsImpl::SetOverrideEncoding(const std::string& encoding) {
2214   SetEncoding(encoding);
2215   Send(new ViewMsg_SetPageEncoding(GetRoutingID(), encoding));
2216 }
2217
2218 void WebContentsImpl::ResetOverrideEncoding() {
2219   canonical_encoding_.clear();
2220   Send(new ViewMsg_ResetPageEncodingToDefault(GetRoutingID()));
2221 }
2222
2223 RendererPreferences* WebContentsImpl::GetMutableRendererPrefs() {
2224   return &renderer_preferences_;
2225 }
2226
2227 void WebContentsImpl::Close() {
2228   Close(GetRenderViewHost());
2229 }
2230
2231 void WebContentsImpl::DragSourceEndedAt(int client_x, int client_y,
2232     int screen_x, int screen_y, blink::WebDragOperation operation) {
2233   if (browser_plugin_embedder_.get())
2234     browser_plugin_embedder_->DragSourceEndedAt(client_x, client_y,
2235         screen_x, screen_y, operation);
2236   if (GetRenderViewHost())
2237     GetRenderViewHostImpl()->DragSourceEndedAt(client_x, client_y,
2238         screen_x, screen_y, operation);
2239 }
2240
2241 void WebContentsImpl::DidGetResourceResponseStart(
2242   const ResourceRequestDetails& details) {
2243   controller_.ssl_manager()->DidStartResourceResponse(details);
2244
2245   FOR_EACH_OBSERVER(WebContentsObserver, observers_,
2246                     DidGetResourceResponseStart(details));
2247
2248   // TODO(avi): Remove. http://crbug.com/170921
2249   NotificationService::current()->Notify(
2250       NOTIFICATION_RESOURCE_RESPONSE_STARTED,
2251       Source<WebContents>(this),
2252       Details<const ResourceRequestDetails>(&details));
2253 }
2254
2255 void WebContentsImpl::DidGetRedirectForResourceRequest(
2256   RenderViewHost* render_view_host,
2257   const ResourceRedirectDetails& details) {
2258   controller_.ssl_manager()->DidReceiveResourceRedirect(details);
2259
2260   FOR_EACH_OBSERVER(
2261       WebContentsObserver,
2262       observers_,
2263       DidGetRedirectForResourceRequest(render_view_host, details));
2264
2265   // TODO(avi): Remove. http://crbug.com/170921
2266   NotificationService::current()->Notify(
2267       NOTIFICATION_RESOURCE_RECEIVED_REDIRECT,
2268       Source<WebContents>(this),
2269       Details<const ResourceRedirectDetails>(&details));
2270 }
2271
2272 void WebContentsImpl::SystemDragEnded() {
2273   if (GetRenderViewHost())
2274     GetRenderViewHostImpl()->DragSourceSystemDragEnded();
2275   if (delegate_)
2276     delegate_->DragEnded();
2277   if (browser_plugin_embedder_.get())
2278     browser_plugin_embedder_->SystemDragEnded();
2279 }
2280
2281 void WebContentsImpl::UserGestureDone() {
2282   OnUserGesture();
2283 }
2284
2285 void WebContentsImpl::SetClosedByUserGesture(bool value) {
2286   closed_by_user_gesture_ = value;
2287 }
2288
2289 bool WebContentsImpl::GetClosedByUserGesture() const {
2290   return closed_by_user_gesture_;
2291 }
2292
2293 void WebContentsImpl::ViewSource() {
2294   if (!delegate_)
2295     return;
2296
2297   NavigationEntry* entry = GetController().GetLastCommittedEntry();
2298   if (!entry)
2299     return;
2300
2301   delegate_->ViewSourceForTab(this, entry->GetURL());
2302 }
2303
2304 void WebContentsImpl::ViewFrameSource(const GURL& url,
2305                                       const PageState& page_state) {
2306   if (!delegate_)
2307     return;
2308
2309   delegate_->ViewSourceForFrame(this, url, page_state);
2310 }
2311
2312 int WebContentsImpl::GetMinimumZoomPercent() const {
2313   return minimum_zoom_percent_;
2314 }
2315
2316 int WebContentsImpl::GetMaximumZoomPercent() const {
2317   return maximum_zoom_percent_;
2318 }
2319
2320 gfx::Size WebContentsImpl::GetPreferredSize() const {
2321   return capturer_count_ == 0 ? preferred_size_ : preferred_size_for_capture_;
2322 }
2323
2324 bool WebContentsImpl::GotResponseToLockMouseRequest(bool allowed) {
2325   if (GetBrowserPluginGuest())
2326     return GetBrowserPluginGuest()->LockMouse(allowed);
2327
2328   return GetRenderViewHost() ?
2329       GetRenderViewHostImpl()->GotResponseToLockMouseRequest(allowed) : false;
2330 }
2331
2332 bool WebContentsImpl::HasOpener() const {
2333   return opener_ != NULL;
2334 }
2335
2336 void WebContentsImpl::DidChooseColorInColorChooser(SkColor color) {
2337   if (!color_chooser_info_.get())
2338     return;
2339   RenderFrameHost* rfh = RenderFrameHost::FromID(
2340       color_chooser_info_->render_process_id,
2341       color_chooser_info_->render_frame_id);
2342   if (!rfh)
2343     return;
2344
2345   rfh->Send(new FrameMsg_DidChooseColorResponse(
2346       rfh->GetRoutingID(), color_chooser_info_->identifier, color));
2347 }
2348
2349 void WebContentsImpl::DidEndColorChooser() {
2350   if (!color_chooser_info_.get())
2351     return;
2352   RenderFrameHost* rfh = RenderFrameHost::FromID(
2353       color_chooser_info_->render_process_id,
2354       color_chooser_info_->render_frame_id);
2355   if (!rfh)
2356     return;
2357
2358   rfh->Send(new FrameMsg_DidEndColorChooser(
2359       rfh->GetRoutingID(), color_chooser_info_->identifier));
2360   color_chooser_info_.reset();
2361 }
2362
2363 int WebContentsImpl::DownloadImage(const GURL& url,
2364                                    bool is_favicon,
2365                                    uint32_t max_bitmap_size,
2366                                    const ImageDownloadCallback& callback) {
2367   int id = StartDownload(GetMainFrame(), url, is_favicon, max_bitmap_size);
2368   image_download_map_[id] = callback;
2369   return id;
2370 }
2371
2372 bool WebContentsImpl::IsSubframe() const {
2373   return is_subframe_;
2374 }
2375
2376 void WebContentsImpl::Find(int request_id,
2377                            const base::string16& search_text,
2378                            const blink::WebFindOptions& options) {
2379   Send(new ViewMsg_Find(GetRoutingID(), request_id, search_text, options));
2380 }
2381
2382 void WebContentsImpl::StopFinding(StopFindAction action) {
2383   Send(new ViewMsg_StopFinding(GetRoutingID(), action));
2384 }
2385
2386 void WebContentsImpl::InsertCSS(const std::string& css) {
2387   GetMainFrame()->Send(new FrameMsg_CSSInsertRequest(
2388       GetMainFrame()->GetRoutingID(), css));
2389 }
2390
2391 bool WebContentsImpl::FocusLocationBarByDefault() {
2392   NavigationEntry* entry = controller_.GetVisibleEntry();
2393   if (entry && entry->GetURL() == GURL(url::kAboutBlankURL))
2394     return true;
2395   return delegate_ && delegate_->ShouldFocusLocationBarByDefault(this);
2396 }
2397
2398 void WebContentsImpl::SetFocusToLocationBar(bool select_all) {
2399   if (delegate_)
2400     delegate_->SetFocusToLocationBar(select_all);
2401 }
2402
2403 void WebContentsImpl::DidStartProvisionalLoad(
2404     RenderFrameHostImpl* render_frame_host,
2405     const GURL& validated_url,
2406     bool is_error_page,
2407     bool is_iframe_srcdoc) {
2408   // Notify observers about the start of the provisional load.
2409   FOR_EACH_OBSERVER(
2410       WebContentsObserver,
2411       observers_,
2412       DidStartProvisionalLoadForFrame(
2413           render_frame_host, validated_url, is_error_page, is_iframe_srcdoc));
2414
2415   if (!render_frame_host->GetParent()) {
2416     FOR_EACH_OBSERVER(
2417         WebContentsObserver,
2418         observers_,
2419         ProvisionalChangeToMainFrameUrl(validated_url,
2420                                         render_frame_host));
2421   }
2422 }
2423
2424 void WebContentsImpl::DidStartNavigationTransition(
2425     RenderFrameHostImpl* render_frame_host) {
2426 #if defined(OS_ANDROID)
2427   int render_frame_id = render_frame_host->GetRoutingID();
2428   GetWebContentsAndroid()->DidStartNavigationTransitionForFrame(
2429       render_frame_id);
2430 #endif
2431 }
2432
2433 void WebContentsImpl::DidFailProvisionalLoadWithError(
2434     RenderFrameHostImpl* render_frame_host,
2435     const FrameHostMsg_DidFailProvisionalLoadWithError_Params& params) {
2436   GURL validated_url(params.url);
2437   FOR_EACH_OBSERVER(WebContentsObserver,
2438                     observers_,
2439                     DidFailProvisionalLoad(render_frame_host,
2440                                            validated_url,
2441                                            params.error_code,
2442                                            params.error_description));
2443 }
2444
2445 void WebContentsImpl::DidFailLoadWithError(
2446     RenderFrameHostImpl* render_frame_host,
2447     const GURL& url,
2448     int error_code,
2449     const base::string16& error_description) {
2450   FOR_EACH_OBSERVER(
2451       WebContentsObserver,
2452       observers_,
2453       DidFailLoad(render_frame_host, url, error_code, error_description));
2454 }
2455
2456 void WebContentsImpl::NotifyChangedNavigationState(
2457     InvalidateTypes changed_flags) {
2458   NotifyNavigationStateChanged(changed_flags);
2459 }
2460
2461 void WebContentsImpl::AboutToNavigateRenderFrame(
2462       RenderFrameHostImpl* render_frame_host) {
2463   // Notify observers that we will navigate in this RenderView.
2464   RenderViewHost* render_view_host = render_frame_host->render_view_host();
2465   FOR_EACH_OBSERVER(
2466       WebContentsObserver,
2467       observers_,
2468       AboutToNavigateRenderView(render_view_host));
2469 }
2470
2471 void WebContentsImpl::DidStartNavigationToPendingEntry(
2472       RenderFrameHostImpl* render_frame_host,
2473       const GURL& url,
2474       NavigationController::ReloadType reload_type) {
2475   // Notify observers about navigation.
2476   FOR_EACH_OBSERVER(
2477       WebContentsObserver,
2478       observers_,
2479       DidStartNavigationToPendingEntry(url, reload_type));
2480 }
2481
2482 void WebContentsImpl::RequestOpenURL(RenderFrameHostImpl* render_frame_host,
2483                                      const OpenURLParams& params) {
2484   int source_render_frame_id = render_frame_host->GetRoutingID();
2485   WebContents* new_contents = OpenURL(params);
2486
2487   if (new_contents) {
2488     // Notify observers.
2489     FOR_EACH_OBSERVER(WebContentsObserver, observers_,
2490                       DidOpenRequestedURL(new_contents,
2491                                           params.url,
2492                                           params.referrer,
2493                                           params.disposition,
2494                                           params.transition,
2495                                           source_render_frame_id));
2496   }
2497 }
2498
2499 bool WebContentsImpl::ShouldPreserveAbortedURLs() {
2500   if (!delegate_)
2501     return false;
2502   return delegate_->ShouldPreserveAbortedURLs(this);
2503 }
2504
2505 void WebContentsImpl::DidRedirectProvisionalLoad(
2506     RenderFrameHostImpl* render_frame_host,
2507     const GURL& validated_target_url) {
2508   // Notify observers about the provisional change in the main frame URL.
2509   FOR_EACH_OBSERVER(
2510       WebContentsObserver,
2511       observers_,
2512       ProvisionalChangeToMainFrameUrl(validated_target_url,
2513                                       render_frame_host));
2514 }
2515
2516 void WebContentsImpl::DidCommitProvisionalLoad(
2517     RenderFrameHostImpl* render_frame_host,
2518     const GURL& url,
2519     PageTransition transition_type) {
2520   // Notify observers about the commit of the provisional load.
2521   FOR_EACH_OBSERVER(WebContentsObserver,
2522                     observers_,
2523                     DidCommitProvisionalLoadForFrame(
2524                         render_frame_host, url, transition_type));
2525 }
2526
2527 void WebContentsImpl::DidNavigateMainFramePreCommit(
2528     bool navigation_is_within_page) {
2529   // Ensure fullscreen mode is exited before committing the navigation to a
2530   // different page.  The next page will not start out assuming it is in
2531   // fullscreen mode.
2532   if (navigation_is_within_page) {
2533     // No page change?  Then, the renderer and browser can remain in fullscreen.
2534     return;
2535   }
2536   if (IsFullscreenForCurrentTab())
2537     GetRenderViewHost()->ExitFullscreen();
2538   DCHECK(!IsFullscreenForCurrentTab());
2539 }
2540
2541 void WebContentsImpl::DidNavigateMainFramePostCommit(
2542     const LoadCommittedDetails& details,
2543     const FrameHostMsg_DidCommitProvisionalLoad_Params& params) {
2544   if (details.is_navigation_to_different_page()) {
2545     // Clear the status bubble. This is a workaround for a bug where WebKit
2546     // doesn't let us know that the cursor left an element during a
2547     // transition (this is also why the mouse cursor remains as a hand after
2548     // clicking on a link); see bugs 1184641 and 980803. We don't want to
2549     // clear the bubble when a user navigates to a named anchor in the same
2550     // page.
2551     UpdateTargetURL(details.entry->GetPageID(), GURL());
2552   }
2553
2554   if (!details.is_in_page) {
2555     // Once the main frame is navigated, we're no longer considered to have
2556     // displayed insecure content.
2557     displayed_insecure_content_ = false;
2558     SSLManager::NotifySSLInternalStateChanged(
2559         GetController().GetBrowserContext());
2560   }
2561
2562   // Notify observers about navigation.
2563   FOR_EACH_OBSERVER(WebContentsObserver, observers_,
2564                     DidNavigateMainFrame(details, params));
2565
2566   if (delegate_)
2567     delegate_->DidNavigateMainFramePostCommit(this);
2568   view_->SetOverscrollControllerEnabled(CanOverscrollContent());
2569 }
2570
2571 void WebContentsImpl::DidNavigateAnyFramePostCommit(
2572     RenderFrameHostImpl* render_frame_host,
2573     const LoadCommittedDetails& details,
2574     const FrameHostMsg_DidCommitProvisionalLoad_Params& params) {
2575   // Now that something has committed, we don't need to track whether the
2576   // initial page has been accessed.
2577   has_accessed_initial_document_ = false;
2578
2579   // If we navigate off the page, close all JavaScript dialogs.
2580   if (dialog_manager_ && !details.is_in_page)
2581     dialog_manager_->CancelActiveAndPendingDialogs(this);
2582
2583   // Notify observers about navigation.
2584   FOR_EACH_OBSERVER(WebContentsObserver, observers_,
2585                     DidNavigateAnyFrame(details, params));
2586 }
2587
2588 void WebContentsImpl::SetMainFrameMimeType(const std::string& mime_type) {
2589   contents_mime_type_ = mime_type;
2590 }
2591
2592 bool WebContentsImpl::CanOverscrollContent() const {
2593   // Disable overscroll when touch emulation is on. See crbug.com/369938.
2594   if (force_disable_overscroll_content_)
2595     return false;
2596
2597   if (delegate_)
2598     return delegate_->CanOverscrollContent();
2599
2600   return false;
2601 }
2602
2603 void WebContentsImpl::OnThemeColorChanged(SkColor theme_color) {
2604   FOR_EACH_OBSERVER(WebContentsObserver, observers_,
2605                     DidChangeThemeColor(theme_color));
2606 }
2607
2608 void WebContentsImpl::OnDidLoadResourceFromMemoryCache(
2609     const GURL& url,
2610     const std::string& security_info,
2611     const std::string& http_method,
2612     const std::string& mime_type,
2613     ResourceType resource_type) {
2614   base::StatsCounter cache("WebKit.CacheHit");
2615   cache.Increment();
2616
2617   // Send out a notification that we loaded a resource from our memory cache.
2618   int cert_id = 0;
2619   net::CertStatus cert_status = 0;
2620   int security_bits = -1;
2621   int connection_status = 0;
2622   SignedCertificateTimestampIDStatusList signed_certificate_timestamp_ids;
2623   DeserializeSecurityInfo(security_info, &cert_id, &cert_status,
2624                           &security_bits, &connection_status,
2625                           &signed_certificate_timestamp_ids);
2626   // TODO(alcutter,eranm): Pass signed_certificate_timestamp_ids into details
2627   LoadFromMemoryCacheDetails details(
2628       url, GetRenderProcessHost()->GetID(), cert_id, cert_status, http_method,
2629       mime_type, resource_type);
2630
2631   controller_.ssl_manager()->DidLoadFromMemoryCache(details);
2632
2633   FOR_EACH_OBSERVER(WebContentsObserver, observers_,
2634                     DidLoadResourceFromMemoryCache(details));
2635
2636   if (url.is_valid() && url.SchemeIsHTTPOrHTTPS()) {
2637     scoped_refptr<net::URLRequestContextGetter> request_context(
2638         resource_type == RESOURCE_TYPE_MEDIA ?
2639             GetBrowserContext()->GetMediaRequestContextForRenderProcess(
2640                 GetRenderProcessHost()->GetID()) :
2641             GetBrowserContext()->GetRequestContextForRenderProcess(
2642                 GetRenderProcessHost()->GetID()));
2643     BrowserThread::PostTask(
2644         BrowserThread::IO,
2645         FROM_HERE,
2646         base::Bind(&NotifyCacheOnIO, request_context, url, http_method));
2647   }
2648 }
2649
2650 void WebContentsImpl::OnDidDisplayInsecureContent() {
2651   RecordAction(base::UserMetricsAction("SSL.DisplayedInsecureContent"));
2652   displayed_insecure_content_ = true;
2653   SSLManager::NotifySSLInternalStateChanged(
2654       GetController().GetBrowserContext());
2655 }
2656
2657 void WebContentsImpl::OnDidRunInsecureContent(
2658     const std::string& security_origin, const GURL& target_url) {
2659   LOG(WARNING) << security_origin << " ran insecure content from "
2660                << target_url.possibly_invalid_spec();
2661   RecordAction(base::UserMetricsAction("SSL.RanInsecureContent"));
2662   if (EndsWith(security_origin, kDotGoogleDotCom, false))
2663     RecordAction(base::UserMetricsAction("SSL.RanInsecureContentGoogle"));
2664   controller_.ssl_manager()->DidRunInsecureContent(security_origin);
2665   displayed_insecure_content_ = true;
2666   SSLManager::NotifySSLInternalStateChanged(
2667       GetController().GetBrowserContext());
2668 }
2669
2670 void WebContentsImpl::OnDocumentLoadedInFrame() {
2671   CHECK(render_frame_message_source_);
2672   CHECK(!render_view_message_source_);
2673   RenderFrameHostImpl* rfh =
2674       static_cast<RenderFrameHostImpl*>(render_frame_message_source_);
2675   FOR_EACH_OBSERVER(
2676       WebContentsObserver, observers_, DocumentLoadedInFrame(rfh));
2677 }
2678
2679 void WebContentsImpl::OnDidFinishLoad(
2680     const GURL& url) {
2681   if (!render_frame_message_source_) {
2682     RecordAction(base::UserMetricsAction("BadMessageTerminate_RVD2"));
2683     GetRenderProcessHost()->ReceivedBadMessage();
2684     return;
2685   }
2686
2687   GURL validated_url(url);
2688   RenderProcessHost* render_process_host =
2689       render_frame_message_source_->GetProcess();
2690   render_process_host->FilterURL(false, &validated_url);
2691
2692   RenderFrameHostImpl* rfh =
2693       static_cast<RenderFrameHostImpl*>(render_frame_message_source_);
2694   FOR_EACH_OBSERVER(
2695       WebContentsObserver, observers_, DidFinishLoad(rfh, validated_url));
2696 }
2697
2698 void WebContentsImpl::OnDidStartLoading(bool to_different_document) {
2699   RenderFrameHostImpl* rfh =
2700       static_cast<RenderFrameHostImpl*>(render_frame_message_source_);
2701   int64 render_frame_id = rfh->frame_tree_node()->frame_tree_node_id();
2702
2703   // It is possible to get multiple calls to OnDidStartLoading that don't have
2704   // corresponding calls to OnDidStopLoading:
2705   // - With "swappedout://" URLs, this happens when a RenderView gets swapped
2706   //   out for a cross-process navigation, and it turns into a placeholder for
2707   //   one being rendered in a different process.
2708   // - Also, there might be more than one RenderFrameHost sharing the same
2709   //   FrameTreeNode (and thus sharing its ID) each sending a start.
2710   // - But in the future, once clamy@ moves navigation network requests to the
2711   //   browser process, there's a good chance that callbacks about starting and
2712   //   stopping will all be handled by the browser. When that happens, there
2713   //   should no longer be a start/stop call imbalance. TODO(avi): When this
2714   //   future arrives, update this code to not allow this case.
2715   DCHECK_GE(loading_frames_in_progress_, 0);
2716   if (loading_progresses_.find(render_frame_id) == loading_progresses_.end()) {
2717     if (loading_frames_in_progress_ == 0)
2718       DidStartLoading(rfh, to_different_document);
2719     ++loading_frames_in_progress_;
2720   }
2721
2722   loading_progresses_[render_frame_id] = kMinimumLoadingProgress;
2723   SendLoadProgressChanged();
2724 }
2725
2726 void WebContentsImpl::OnDidStopLoading() {
2727   RenderFrameHostImpl* rfh =
2728       static_cast<RenderFrameHostImpl*>(render_frame_message_source_);
2729   int64 render_frame_id = rfh->frame_tree_node()->frame_tree_node_id();
2730
2731   if (loading_progresses_.find(render_frame_id) != loading_progresses_.end()) {
2732     // Load stopped while we were still tracking load.  Make sure we update
2733     // progress based on this frame's completion.
2734     loading_progresses_[render_frame_id] = 1.0;
2735     SendLoadProgressChanged();
2736     // Then we clean-up our states.
2737     if (loading_total_progress_ == 1.0)
2738       ResetLoadProgressState();
2739   }
2740
2741   // TODO(japhet): This should be a DCHECK, but the pdf plugin sometimes
2742   // calls DidStopLoading() without a matching DidStartLoading().
2743   if (loading_frames_in_progress_ == 0)
2744     return;
2745   --loading_frames_in_progress_;
2746   if (loading_frames_in_progress_ == 0)
2747     DidStopLoading(rfh);
2748 }
2749
2750 void WebContentsImpl::OnDidChangeLoadProgress(double load_progress) {
2751   RenderFrameHostImpl* rfh =
2752       static_cast<RenderFrameHostImpl*>(render_frame_message_source_);
2753   int64 render_frame_id = rfh->frame_tree_node()->frame_tree_node_id();
2754
2755   loading_progresses_[render_frame_id] = load_progress;
2756
2757   // We notify progress change immediately for the first and last updates.
2758   // Also, since the message loop may be pretty busy when a page is loaded, it
2759   // might not execute a posted task in a timely manner so we make sure to
2760   // immediately send progress report if enough time has passed.
2761   base::TimeDelta min_delay =
2762       base::TimeDelta::FromMilliseconds(kMinimumDelayBetweenLoadingUpdatesMS);
2763   if (load_progress == 1.0 || loading_last_progress_update_.is_null() ||
2764       base::TimeTicks::Now() - loading_last_progress_update_ > min_delay) {
2765     // If there is a pending task to send progress, it is now obsolete.
2766     loading_weak_factory_.InvalidateWeakPtrs();
2767     SendLoadProgressChanged();
2768     if (loading_total_progress_ == 1.0)
2769       ResetLoadProgressState();
2770     return;
2771   }
2772
2773   if (loading_weak_factory_.HasWeakPtrs())
2774     return;
2775
2776   base::MessageLoop::current()->PostDelayedTask(
2777       FROM_HERE,
2778       base::Bind(&WebContentsImpl::SendLoadProgressChanged,
2779                  loading_weak_factory_.GetWeakPtr()),
2780       min_delay);
2781 }
2782
2783 void WebContentsImpl::OnGoToEntryAtOffset(int offset) {
2784   if (!delegate_ || delegate_->OnGoToEntryOffset(offset))
2785     controller_.GoToOffset(offset);
2786 }
2787
2788 void WebContentsImpl::OnUpdateZoomLimits(int minimum_percent,
2789                                          int maximum_percent) {
2790   minimum_zoom_percent_ = minimum_percent;
2791   maximum_zoom_percent_ = maximum_percent;
2792 }
2793
2794 void WebContentsImpl::OnEnumerateDirectory(int request_id,
2795                                            const base::FilePath& path) {
2796   if (!delegate_)
2797     return;
2798
2799   ChildProcessSecurityPolicyImpl* policy =
2800       ChildProcessSecurityPolicyImpl::GetInstance();
2801   if (policy->CanReadFile(GetRenderProcessHost()->GetID(), path))
2802     delegate_->EnumerateDirectory(this, request_id, path);
2803 }
2804
2805 void WebContentsImpl::OnRegisterProtocolHandler(const std::string& protocol,
2806                                                 const GURL& url,
2807                                                 const base::string16& title,
2808                                                 bool user_gesture) {
2809   if (!delegate_)
2810     return;
2811
2812   ChildProcessSecurityPolicyImpl* policy =
2813       ChildProcessSecurityPolicyImpl::GetInstance();
2814   if (policy->IsPseudoScheme(protocol))
2815     return;
2816
2817   delegate_->RegisterProtocolHandler(this, protocol, url, user_gesture);
2818 }
2819
2820 void WebContentsImpl::OnUnregisterProtocolHandler(const std::string& protocol,
2821                                                   const GURL& url,
2822                                                   bool user_gesture) {
2823   if (!delegate_)
2824     return;
2825
2826   ChildProcessSecurityPolicyImpl* policy =
2827       ChildProcessSecurityPolicyImpl::GetInstance();
2828   if (policy->IsPseudoScheme(protocol))
2829     return;
2830
2831   delegate_->UnregisterProtocolHandler(this, protocol, url, user_gesture);
2832 }
2833
2834 void WebContentsImpl::OnFindReply(int request_id,
2835                                   int number_of_matches,
2836                                   const gfx::Rect& selection_rect,
2837                                   int active_match_ordinal,
2838                                   bool final_update) {
2839   if (delegate_) {
2840     delegate_->FindReply(this, request_id, number_of_matches, selection_rect,
2841                          active_match_ordinal, final_update);
2842   }
2843 }
2844
2845 #if defined(OS_ANDROID)
2846 void WebContentsImpl::OnFindMatchRectsReply(
2847     int version,
2848     const std::vector<gfx::RectF>& rects,
2849     const gfx::RectF& active_rect) {
2850   if (delegate_)
2851     delegate_->FindMatchRectsReply(this, version, rects, active_rect);
2852 }
2853
2854 void WebContentsImpl::OnOpenDateTimeDialog(
2855     const ViewHostMsg_DateTimeDialogValue_Params& value) {
2856   date_time_chooser_->ShowDialog(ContentViewCore::FromWebContents(this),
2857                                  GetRenderViewHost(),
2858                                  value.dialog_type,
2859                                  value.dialog_value,
2860                                  value.minimum,
2861                                  value.maximum,
2862                                  value.step,
2863                                  value.suggestions);
2864 }
2865
2866 #endif
2867
2868 void WebContentsImpl::OnPepperPluginHung(int plugin_child_id,
2869                                          const base::FilePath& path,
2870                                          bool is_hung) {
2871   UMA_HISTOGRAM_COUNTS("Pepper.PluginHung", 1);
2872
2873   FOR_EACH_OBSERVER(WebContentsObserver, observers_,
2874                     PluginHungStatusChanged(plugin_child_id, path, is_hung));
2875 }
2876
2877 void WebContentsImpl::OnPluginCrashed(const base::FilePath& plugin_path,
2878                                       base::ProcessId plugin_pid) {
2879   FOR_EACH_OBSERVER(WebContentsObserver, observers_,
2880                     PluginCrashed(plugin_path, plugin_pid));
2881 }
2882
2883 void WebContentsImpl::OnDomOperationResponse(const std::string& json_string,
2884                                              int automation_id) {
2885   DomOperationNotificationDetails details(json_string, automation_id);
2886   NotificationService::current()->Notify(
2887       NOTIFICATION_DOM_OPERATION_RESPONSE,
2888       Source<WebContents>(this),
2889       Details<DomOperationNotificationDetails>(&details));
2890 }
2891
2892 void WebContentsImpl::OnAppCacheAccessed(const GURL& manifest_url,
2893                                          bool blocked_by_policy) {
2894   // Notify observers about navigation.
2895   FOR_EACH_OBSERVER(WebContentsObserver, observers_,
2896                     AppCacheAccessed(manifest_url, blocked_by_policy));
2897 }
2898
2899 void WebContentsImpl::OnOpenColorChooser(
2900     int color_chooser_id,
2901     SkColor color,
2902     const std::vector<ColorSuggestion>& suggestions) {
2903   ColorChooser* new_color_chooser = delegate_ ?
2904       delegate_->OpenColorChooser(this, color, suggestions) :
2905       NULL;
2906   if (!new_color_chooser)
2907     return;
2908   if (color_chooser_info_.get())
2909     color_chooser_info_->chooser->End();
2910
2911   color_chooser_info_.reset(new ColorChooserInfo(
2912       render_frame_message_source_->GetProcess()->GetID(),
2913       render_frame_message_source_->GetRoutingID(),
2914       new_color_chooser,
2915       color_chooser_id));
2916 }
2917
2918 void WebContentsImpl::OnEndColorChooser(int color_chooser_id) {
2919   if (color_chooser_info_ &&
2920       color_chooser_id == color_chooser_info_->identifier)
2921     color_chooser_info_->chooser->End();
2922 }
2923
2924 void WebContentsImpl::OnSetSelectedColorInColorChooser(int color_chooser_id,
2925                                                        SkColor color) {
2926   if (color_chooser_info_ &&
2927       color_chooser_id == color_chooser_info_->identifier)
2928     color_chooser_info_->chooser->SetSelectedColor(color);
2929 }
2930
2931 // This exists for render views that don't have a WebUI, but do have WebUI
2932 // bindings enabled.
2933 void WebContentsImpl::OnWebUISend(const GURL& source_url,
2934                                   const std::string& name,
2935                                   const base::ListValue& args) {
2936   if (delegate_)
2937     delegate_->WebUISend(this, source_url, name, args);
2938 }
2939
2940 void WebContentsImpl::OnRequestPpapiBrokerPermission(
2941     int routing_id,
2942     const GURL& url,
2943     const base::FilePath& plugin_path) {
2944   if (!delegate_) {
2945     OnPpapiBrokerPermissionResult(routing_id, false);
2946     return;
2947   }
2948
2949   if (!delegate_->RequestPpapiBrokerPermission(
2950       this, url, plugin_path,
2951       base::Bind(&WebContentsImpl::OnPpapiBrokerPermissionResult,
2952                  base::Unretained(this), routing_id))) {
2953     NOTIMPLEMENTED();
2954     OnPpapiBrokerPermissionResult(routing_id, false);
2955   }
2956 }
2957
2958 void WebContentsImpl::OnPpapiBrokerPermissionResult(int routing_id,
2959                                                     bool result) {
2960   Send(new ViewMsg_PpapiBrokerPermissionResult(routing_id, result));
2961 }
2962
2963 void WebContentsImpl::OnBrowserPluginMessage(const IPC::Message& message) {
2964   // This creates a BrowserPluginEmbedder, which handles all the BrowserPlugin
2965   // specific messages for this WebContents. This means that any message from
2966   // a BrowserPlugin prior to this will be ignored.
2967   // For more info, see comment above classes BrowserPluginEmbedder and
2968   // BrowserPluginGuest.
2969   CHECK(!browser_plugin_embedder_.get());
2970   browser_plugin_embedder_.reset(BrowserPluginEmbedder::Create(this));
2971   browser_plugin_embedder_->OnMessageReceived(message);
2972 }
2973
2974 void WebContentsImpl::OnDidDownloadImage(
2975     int id,
2976     int http_status_code,
2977     const GURL& image_url,
2978     const std::vector<SkBitmap>& bitmaps,
2979     const std::vector<gfx::Size>& original_bitmap_sizes) {
2980   if (bitmaps.size() != original_bitmap_sizes.size())
2981     return;
2982
2983   ImageDownloadMap::iterator iter = image_download_map_.find(id);
2984   if (iter == image_download_map_.end()) {
2985     // Currently WebContents notifies us of ANY downloads so that it is
2986     // possible to get here.
2987     return;
2988   }
2989   if (!iter->second.is_null()) {
2990     iter->second.Run(
2991         id, http_status_code, image_url, bitmaps, original_bitmap_sizes);
2992   }
2993   image_download_map_.erase(id);
2994 }
2995
2996 void WebContentsImpl::OnUpdateFaviconURL(
2997     const std::vector<FaviconURL>& candidates) {
2998   FOR_EACH_OBSERVER(WebContentsObserver, observers_,
2999                     DidUpdateFaviconURL(candidates));
3000 }
3001
3002 void WebContentsImpl::OnMediaPlayingNotification(int64 player_cookie,
3003                                                  bool has_video,
3004                                                  bool has_audio) {
3005 #if !defined(OS_CHROMEOS)
3006   scoped_ptr<PowerSaveBlocker> blocker;
3007   if (has_video) {
3008     blocker = PowerSaveBlocker::Create(
3009         PowerSaveBlocker::kPowerSaveBlockPreventDisplaySleep, "Playing video");
3010 #if defined(OS_ANDROID)
3011     static_cast<PowerSaveBlockerImpl*>(blocker.get())
3012         ->InitDisplaySleepBlocker(GetView()->GetNativeView());
3013 #endif
3014   } else if (has_audio) {
3015     blocker = PowerSaveBlocker::Create(
3016         PowerSaveBlocker::kPowerSaveBlockPreventAppSuspension, "Playing audio");
3017   }
3018
3019   if (blocker) {
3020     uintptr_t key = reinterpret_cast<uintptr_t>(render_frame_message_source_);
3021     if (!power_save_blockers_.contains(key)) {
3022       power_save_blockers_.add(key,
3023                                make_scoped_ptr(new PowerSaveBlockerMapEntry));
3024     }
3025     PowerSaveBlockerMapEntry* map_entry =
3026         power_save_blockers_.get(key);
3027     map_entry->set(player_cookie, blocker.Pass());
3028   }
3029 #endif  // !defined(OS_CHROMEOS)
3030 }
3031
3032 void WebContentsImpl::OnMediaPausedNotification(int64 player_cookie) {
3033 #if !defined(OS_CHROMEOS)
3034   uintptr_t key = reinterpret_cast<uintptr_t>(render_frame_message_source_);
3035   PowerSaveBlockerMapEntry* map_entry = power_save_blockers_.get(key);
3036   if (map_entry)
3037     map_entry->erase(player_cookie);
3038 #endif  // !defined(OS_CHROMEOS)
3039 }
3040
3041 void WebContentsImpl::OnFirstVisuallyNonEmptyPaint() {
3042   FOR_EACH_OBSERVER(WebContentsObserver, observers_,
3043                     DidFirstVisuallyNonEmptyPaint());
3044 }
3045
3046 void WebContentsImpl::DidChangeVisibleSSLState() {
3047   if (delegate_)
3048     delegate_->VisibleSSLStateChanged(this);
3049 }
3050
3051 void WebContentsImpl::NotifyBeforeFormRepostWarningShow() {
3052   FOR_EACH_OBSERVER(WebContentsObserver, observers_,
3053                     BeforeFormRepostWarningShow());
3054 }
3055
3056
3057 void WebContentsImpl::ActivateAndShowRepostFormWarningDialog() {
3058   Activate();
3059   if (delegate_)
3060     delegate_->ShowRepostFormWarningDialog(this);
3061 }
3062
3063 bool WebContentsImpl::HasAccessedInitialDocument() {
3064   return has_accessed_initial_document_;
3065 }
3066
3067 // Notifies the RenderWidgetHost instance about the fact that the page is
3068 // loading, or done loading.
3069 void WebContentsImpl::SetIsLoading(RenderViewHost* render_view_host,
3070                                    bool is_loading,
3071                                    bool to_different_document,
3072                                    LoadNotificationDetails* details) {
3073   if (is_loading == is_loading_)
3074     return;
3075
3076   if (!is_loading) {
3077     load_state_ = net::LoadStateWithParam(net::LOAD_STATE_IDLE,
3078                                           base::string16());
3079     load_state_host_.clear();
3080     upload_size_ = 0;
3081     upload_position_ = 0;
3082   }
3083
3084   GetRenderManager()->SetIsLoading(is_loading);
3085
3086   is_loading_ = is_loading;
3087   waiting_for_response_ = is_loading;
3088   is_load_to_different_document_ = to_different_document;
3089
3090   if (delegate_)
3091     delegate_->LoadingStateChanged(this, to_different_document);
3092   NotifyNavigationStateChanged(INVALIDATE_TYPE_LOAD);
3093
3094   std::string url = (details ? details->url.possibly_invalid_spec() : "NULL");
3095   if (is_loading) {
3096     TRACE_EVENT_ASYNC_BEGIN1("browser", "WebContentsImpl Loading", this,
3097                              "URL", url);
3098     FOR_EACH_OBSERVER(WebContentsObserver, observers_,
3099                       DidStartLoading(render_view_host));
3100   } else {
3101     TRACE_EVENT_ASYNC_END1("browser", "WebContentsImpl Loading", this,
3102                            "URL", url);
3103     FOR_EACH_OBSERVER(WebContentsObserver, observers_,
3104                       DidStopLoading(render_view_host));
3105   }
3106
3107   // TODO(avi): Remove. http://crbug.com/170921
3108   int type = is_loading ? NOTIFICATION_LOAD_START : NOTIFICATION_LOAD_STOP;
3109   NotificationDetails det = NotificationService::NoDetails();
3110   if (details)
3111       det = Details<LoadNotificationDetails>(details);
3112   NotificationService::current()->Notify(
3113       type, Source<NavigationController>(&controller_), det);
3114 }
3115
3116 void WebContentsImpl::SelectRange(const gfx::Point& start,
3117                                   const gfx::Point& end) {
3118   RenderFrameHost* focused_frame = GetFocusedFrame();
3119   if (!focused_frame)
3120     return;
3121
3122   focused_frame->Send(
3123       new InputMsg_SelectRange(focused_frame->GetRoutingID(), start, end));
3124 }
3125
3126 void WebContentsImpl::UpdateMaxPageIDIfNecessary(RenderViewHost* rvh) {
3127   // If we are creating a RVH for a restored controller, then we need to make
3128   // sure the RenderView starts with a next_page_id_ larger than the number
3129   // of restored entries.  This must be called before the RenderView starts
3130   // navigating (to avoid a race between the browser updating max_page_id and
3131   // the renderer updating next_page_id_).  Because of this, we only call this
3132   // from CreateRenderView and allow that to notify the RenderView for us.
3133   int max_restored_page_id = controller_.GetMaxRestoredPageID();
3134   if (max_restored_page_id >
3135       GetMaxPageIDForSiteInstance(rvh->GetSiteInstance()))
3136     UpdateMaxPageIDForSiteInstance(rvh->GetSiteInstance(),
3137                                    max_restored_page_id);
3138 }
3139
3140 bool WebContentsImpl::UpdateTitleForEntry(NavigationEntryImpl* entry,
3141                                           const base::string16& title) {
3142   // For file URLs without a title, use the pathname instead. In the case of a
3143   // synthesized title, we don't want the update to count toward the "one set
3144   // per page of the title to history."
3145   base::string16 final_title;
3146   bool explicit_set;
3147   if (entry && entry->GetURL().SchemeIsFile() && title.empty()) {
3148     final_title = base::UTF8ToUTF16(entry->GetURL().ExtractFileName());
3149     explicit_set = false;  // Don't count synthetic titles toward the set limit.
3150   } else {
3151     base::TrimWhitespace(title, base::TRIM_ALL, &final_title);
3152     explicit_set = true;
3153   }
3154
3155   // If a page is created via window.open and never navigated,
3156   // there will be no navigation entry. In this situation,
3157   // |page_title_when_no_navigation_entry_| will be used for page title.
3158   if (entry) {
3159     if (final_title == entry->GetTitle())
3160       return false;  // Nothing changed, don't bother.
3161
3162     entry->SetTitle(final_title);
3163   } else {
3164     if (page_title_when_no_navigation_entry_ == final_title)
3165       return false;  // Nothing changed, don't bother.
3166
3167     page_title_when_no_navigation_entry_ = final_title;
3168   }
3169
3170   // Lastly, set the title for the view.
3171   view_->SetPageTitle(final_title);
3172
3173   FOR_EACH_OBSERVER(WebContentsObserver, observers_,
3174                     TitleWasSet(entry, explicit_set));
3175
3176   // TODO(avi): Remove. http://crbug.com/170921
3177   std::pair<NavigationEntry*, bool> details =
3178       std::make_pair(entry, explicit_set);
3179   NotificationService::current()->Notify(
3180       NOTIFICATION_WEB_CONTENTS_TITLE_UPDATED,
3181       Source<WebContents>(this),
3182       Details<std::pair<NavigationEntry*, bool> >(&details));
3183
3184   return true;
3185 }
3186
3187 void WebContentsImpl::SendLoadProgressChanged() {
3188   loading_last_progress_update_ = base::TimeTicks::Now();
3189   double progress = 0.0;
3190   int frame_count = 0;
3191
3192   for (LoadingProgressMap::iterator it = loading_progresses_.begin();
3193        it != loading_progresses_.end();
3194        ++it) {
3195     progress += it->second;
3196     ++frame_count;
3197   }
3198   if (frame_count == 0)
3199     return;
3200   progress /= frame_count;
3201   DCHECK(progress <= 1.0);
3202
3203   if (progress <= loading_total_progress_)
3204     return;
3205   loading_total_progress_ = progress;
3206
3207   if (delegate_)
3208     delegate_->LoadProgressChanged(this, progress);
3209 }
3210
3211 void WebContentsImpl::ResetLoadProgressState() {
3212   loading_progresses_.clear();
3213   loading_total_progress_ = 0.0;
3214   loading_weak_factory_.InvalidateWeakPtrs();
3215   loading_last_progress_update_ = base::TimeTicks();
3216 }
3217
3218 void WebContentsImpl::NotifyViewSwapped(RenderViewHost* old_host,
3219                                         RenderViewHost* new_host) {
3220   // After sending out a swap notification, we need to send a disconnect
3221   // notification so that clients that pick up a pointer to |this| can NULL the
3222   // pointer.  See Bug 1230284.
3223   notify_disconnection_ = true;
3224   FOR_EACH_OBSERVER(WebContentsObserver, observers_,
3225                     RenderViewHostChanged(old_host, new_host));
3226
3227   // TODO(avi): Remove. http://crbug.com/170921
3228   std::pair<RenderViewHost*, RenderViewHost*> details =
3229       std::make_pair(old_host, new_host);
3230   NotificationService::current()->Notify(
3231       NOTIFICATION_RENDER_VIEW_HOST_CHANGED,
3232       Source<WebContents>(this),
3233       Details<std::pair<RenderViewHost*, RenderViewHost*> >(&details));
3234
3235   // Ensure that the associated embedder gets cleared after a RenderViewHost
3236   // gets swapped, so we don't reuse the same embedder next time a
3237   // RenderViewHost is attached to this WebContents.
3238   RemoveBrowserPluginEmbedder();
3239 }
3240
3241 void WebContentsImpl::NotifyFrameSwapped(RenderFrameHost* old_host,
3242                                          RenderFrameHost* new_host) {
3243   FOR_EACH_OBSERVER(WebContentsObserver,
3244                     observers_,
3245                     RenderFrameHostChanged(old_host, new_host));
3246 }
3247
3248 // TODO(avi): Remove this entire function because this notification is already
3249 // covered by two observer functions. http://crbug.com/170921
3250 void WebContentsImpl::NotifyDisconnected() {
3251   if (!notify_disconnection_)
3252     return;
3253
3254   notify_disconnection_ = false;
3255   NotificationService::current()->Notify(
3256       NOTIFICATION_WEB_CONTENTS_DISCONNECTED,
3257       Source<WebContents>(this),
3258       NotificationService::NoDetails());
3259 }
3260
3261 void WebContentsImpl::NotifyNavigationEntryCommitted(
3262     const LoadCommittedDetails& load_details) {
3263   FOR_EACH_OBSERVER(
3264       WebContentsObserver, observers_, NavigationEntryCommitted(load_details));
3265 }
3266
3267 bool WebContentsImpl::OnMessageReceived(RenderFrameHost* render_frame_host,
3268                                         const IPC::Message& message) {
3269   return OnMessageReceived(NULL, render_frame_host, message);
3270 }
3271
3272 const GURL& WebContentsImpl::GetMainFrameLastCommittedURL() const {
3273   return GetLastCommittedURL();
3274 }
3275
3276 void WebContentsImpl::RenderFrameCreated(RenderFrameHost* render_frame_host) {
3277   // Note this is only for subframes, the notification for the main frame
3278   // happens in RenderViewCreated.
3279   FOR_EACH_OBSERVER(WebContentsObserver,
3280                     observers_,
3281                     RenderFrameCreated(render_frame_host));
3282   SetAccessibilityModeOnFrame(accessibility_mode_, render_frame_host);
3283 }
3284
3285 void WebContentsImpl::RenderFrameDeleted(RenderFrameHost* render_frame_host) {
3286   ClearPowerSaveBlockers(render_frame_host);
3287   FOR_EACH_OBSERVER(WebContentsObserver,
3288                     observers_,
3289                     RenderFrameDeleted(render_frame_host));
3290 }
3291
3292 void WebContentsImpl::WorkerCrashed(RenderFrameHost* render_frame_host) {
3293   if (delegate_)
3294     delegate_->WorkerCrashed(this);
3295 }
3296
3297 void WebContentsImpl::ShowContextMenu(RenderFrameHost* render_frame_host,
3298                                       const ContextMenuParams& params) {
3299   ContextMenuParams context_menu_params(params);
3300   // Allow WebContentsDelegates to handle the context menu operation first.
3301   if (GetBrowserPluginGuest()) {
3302     WebContentsViewGuest* view_guest =
3303         static_cast<WebContentsViewGuest*>(GetView());
3304     context_menu_params = view_guest->ConvertContextMenuParams(params);
3305   }
3306   if (delegate_ && delegate_->HandleContextMenu(context_menu_params))
3307     return;
3308
3309   render_view_host_delegate_view_->ShowContextMenu(render_frame_host,
3310                                                    context_menu_params);
3311 }
3312
3313 void WebContentsImpl::RunJavaScriptMessage(
3314     RenderFrameHost* render_frame_host,
3315     const base::string16& message,
3316     const base::string16& default_prompt,
3317     const GURL& frame_url,
3318     JavaScriptMessageType javascript_message_type,
3319     IPC::Message* reply_msg) {
3320   // Suppress JavaScript dialogs when requested. Also suppress messages when
3321   // showing an interstitial as it's shown over the previous page and we don't
3322   // want the hidden page's dialogs to interfere with the interstitial.
3323   bool suppress_this_message =
3324       static_cast<RenderViewHostImpl*>(render_frame_host->GetRenderViewHost())->
3325           IsSwappedOut() ||
3326       ShowingInterstitialPage() ||
3327       !delegate_ ||
3328       delegate_->ShouldSuppressDialogs() ||
3329       !delegate_->GetJavaScriptDialogManager();
3330
3331   if (!suppress_this_message) {
3332     std::string accept_lang = GetContentClient()->browser()->
3333       GetAcceptLangs(GetBrowserContext());
3334     dialog_manager_ = delegate_->GetJavaScriptDialogManager();
3335     dialog_manager_->RunJavaScriptDialog(
3336         this,
3337         frame_url.GetOrigin(),
3338         accept_lang,
3339         javascript_message_type,
3340         message,
3341         default_prompt,
3342         base::Bind(&WebContentsImpl::OnDialogClosed,
3343                    base::Unretained(this),
3344                    render_frame_host->GetProcess()->GetID(),
3345                    render_frame_host->GetRoutingID(),
3346                    reply_msg,
3347                    false),
3348         &suppress_this_message);
3349   }
3350
3351   if (suppress_this_message) {
3352     // If we are suppressing messages, just reply as if the user immediately
3353     // pressed "Cancel", passing true to |dialog_was_suppressed|.
3354     OnDialogClosed(render_frame_host->GetProcess()->GetID(),
3355                    render_frame_host->GetRoutingID(), reply_msg,
3356                    true, false, base::string16());
3357   }
3358
3359   // OnDialogClosed (two lines up) may have caused deletion of this object (see
3360   // http://crbug.com/288961 ). The only safe thing to do here is return.
3361 }
3362
3363 void WebContentsImpl::RunBeforeUnloadConfirm(
3364     RenderFrameHost* render_frame_host,
3365     const base::string16& message,
3366     bool is_reload,
3367     IPC::Message* reply_msg) {
3368   RenderFrameHostImpl* rfhi =
3369       static_cast<RenderFrameHostImpl*>(render_frame_host);
3370   RenderViewHostImpl* rvhi =
3371       static_cast<RenderViewHostImpl*>(render_frame_host->GetRenderViewHost());
3372   if (delegate_)
3373     delegate_->WillRunBeforeUnloadConfirm();
3374
3375   bool suppress_this_message =
3376       rvhi->rvh_state() != RenderViewHostImpl::STATE_DEFAULT ||
3377       !delegate_ ||
3378       delegate_->ShouldSuppressDialogs() ||
3379       !delegate_->GetJavaScriptDialogManager();
3380   if (suppress_this_message) {
3381     rfhi->JavaScriptDialogClosed(reply_msg, true, base::string16(), true);
3382     return;
3383   }
3384
3385   is_showing_before_unload_dialog_ = true;
3386   dialog_manager_ = delegate_->GetJavaScriptDialogManager();
3387   dialog_manager_->RunBeforeUnloadDialog(
3388       this, message, is_reload,
3389       base::Bind(&WebContentsImpl::OnDialogClosed, base::Unretained(this),
3390                  render_frame_host->GetProcess()->GetID(),
3391                  render_frame_host->GetRoutingID(), reply_msg,
3392                  false));
3393 }
3394
3395 WebContents* WebContentsImpl::GetAsWebContents() {
3396   return this;
3397 }
3398
3399 bool WebContentsImpl::IsNeverVisible() {
3400   if (!delegate_)
3401     return false;
3402   return delegate_->IsNeverVisible(this);
3403 }
3404
3405 #if defined(OS_WIN)
3406 gfx::NativeViewAccessible WebContentsImpl::GetParentNativeViewAccessible() {
3407   return accessible_parent_;
3408 }
3409 #endif
3410
3411 RenderViewHostDelegateView* WebContentsImpl::GetDelegateView() {
3412   return render_view_host_delegate_view_;
3413 }
3414
3415 RendererPreferences WebContentsImpl::GetRendererPrefs(
3416     BrowserContext* browser_context) const {
3417   return renderer_preferences_;
3418 }
3419
3420 gfx::Rect WebContentsImpl::GetRootWindowResizerRect() const {
3421   if (delegate_)
3422     return delegate_->GetRootWindowResizerRect();
3423   return gfx::Rect();
3424 }
3425
3426 void WebContentsImpl::RemoveBrowserPluginEmbedder() {
3427   if (browser_plugin_embedder_)
3428     browser_plugin_embedder_.reset();
3429 }
3430
3431 void WebContentsImpl::RenderViewCreated(RenderViewHost* render_view_host) {
3432   // Don't send notifications if we are just creating a swapped-out RVH for
3433   // the opener chain.  These won't be used for view-source or WebUI, so it's
3434   // ok to return early.
3435   if (static_cast<RenderViewHostImpl*>(render_view_host)->IsSwappedOut())
3436     return;
3437
3438   if (delegate_)
3439     view_->SetOverscrollControllerEnabled(CanOverscrollContent());
3440
3441   NotificationService::current()->Notify(
3442       NOTIFICATION_WEB_CONTENTS_RENDER_VIEW_HOST_CREATED,
3443       Source<WebContents>(this),
3444       Details<RenderViewHost>(render_view_host));
3445
3446   // When we're creating views, we're still doing initial setup, so we always
3447   // use the pending Web UI rather than any possibly existing committed one.
3448   if (GetRenderManager()->pending_web_ui())
3449     GetRenderManager()->pending_web_ui()->RenderViewCreated(render_view_host);
3450
3451   NavigationEntry* entry = controller_.GetPendingEntry();
3452   if (entry && entry->IsViewSourceMode()) {
3453     // Put the renderer in view source mode.
3454     render_view_host->Send(
3455         new ViewMsg_EnableViewSourceMode(render_view_host->GetRoutingID()));
3456   }
3457
3458   view_->RenderViewCreated(render_view_host);
3459
3460   FOR_EACH_OBSERVER(
3461       WebContentsObserver, observers_, RenderViewCreated(render_view_host));
3462
3463   // We tell the observers now instead of when the main RenderFrameHostImpl is
3464   // constructed because otherwise it would be too early (i.e. IPCs sent to the
3465   // frame would be dropped because it's not created yet).
3466   RenderFrameHost* main_frame = render_view_host->GetMainFrame();
3467   FOR_EACH_OBSERVER(
3468       WebContentsObserver, observers_, RenderFrameCreated(main_frame));
3469   SetAccessibilityModeOnFrame(accessibility_mode_, main_frame);
3470 }
3471
3472 void WebContentsImpl::RenderViewReady(RenderViewHost* rvh) {
3473   if (rvh != GetRenderViewHost()) {
3474     // Don't notify the world, since this came from a renderer in the
3475     // background.
3476     return;
3477   }
3478
3479   notify_disconnection_ = true;
3480   // TODO(avi): Remove. http://crbug.com/170921
3481   NotificationService::current()->Notify(
3482       NOTIFICATION_WEB_CONTENTS_CONNECTED,
3483       Source<WebContents>(this),
3484       NotificationService::NoDetails());
3485
3486   bool was_crashed = IsCrashed();
3487   SetIsCrashed(base::TERMINATION_STATUS_STILL_RUNNING, 0);
3488
3489   // Restore the focus to the tab (otherwise the focus will be on the top
3490   // window).
3491   if (was_crashed && !FocusLocationBarByDefault() &&
3492       (!delegate_ || delegate_->ShouldFocusPageAfterCrash())) {
3493     view_->Focus();
3494   }
3495
3496   FOR_EACH_OBSERVER(WebContentsObserver, observers_, RenderViewReady());
3497 }
3498
3499 void WebContentsImpl::RenderViewTerminated(RenderViewHost* rvh,
3500                                            base::TerminationStatus status,
3501                                            int error_code) {
3502   if (rvh != GetRenderViewHost()) {
3503     // The pending page's RenderViewHost is gone.
3504     return;
3505   }
3506
3507   // Ensure fullscreen mode is exited in the |delegate_| since a crashed
3508   // renderer may not have made a clean exit.
3509   if (IsFullscreenForCurrentTab())
3510     ToggleFullscreenMode(false);
3511
3512   // Cancel any visible dialogs so they are not left dangling over the sad tab.
3513   if (dialog_manager_)
3514     dialog_manager_->CancelActiveAndPendingDialogs(this);
3515
3516   if (delegate_)
3517     delegate_->HideValidationMessage(this);
3518
3519   SetIsLoading(rvh, false, true, NULL);
3520   NotifyDisconnected();
3521   SetIsCrashed(status, error_code);
3522
3523   // Reset the loading progress. TODO(avi): What does it mean to have a
3524   // "renderer crash" when there is more than one renderer process serving a
3525   // webpage? Once this function is called at a more granular frame level, we
3526   // probably will need to more granularly reset the state here.
3527   ResetLoadProgressState();
3528   loading_frames_in_progress_ = 0;
3529
3530   FOR_EACH_OBSERVER(WebContentsObserver,
3531                     observers_,
3532                     RenderProcessGone(GetCrashedStatus()));
3533 }
3534
3535 void WebContentsImpl::RenderViewDeleted(RenderViewHost* rvh) {
3536   FOR_EACH_OBSERVER(WebContentsObserver, observers_, RenderViewDeleted(rvh));
3537 }
3538
3539 void WebContentsImpl::UpdateState(RenderViewHost* rvh,
3540                                   int32 page_id,
3541                                   const PageState& page_state) {
3542   // Ensure that this state update comes from either the active RVH or one of
3543   // the swapped out RVHs.  We don't expect to hear from any other RVHs.
3544   // TODO(nasko): This should go through RenderFrameHost.
3545   // TODO(creis): We can't update state for cross-process subframes until we
3546   // have FrameNavigationEntries.  Once we do, this should be a DCHECK.
3547   if (rvh != GetRenderViewHost() &&
3548       !GetRenderManager()->IsRVHOnSwappedOutList(
3549           static_cast<RenderViewHostImpl*>(rvh)))
3550     return;
3551
3552   // We must be prepared to handle state updates for any page, these occur
3553   // when the user is scrolling and entering form data, as well as when we're
3554   // leaving a page, in which case our state may have already been moved to
3555   // the next page. The navigation controller will look up the appropriate
3556   // NavigationEntry and update it when it is notified via the delegate.
3557
3558   int entry_index = controller_.GetEntryIndexWithPageID(
3559       rvh->GetSiteInstance(), page_id);
3560   if (entry_index < 0)
3561     return;
3562   NavigationEntry* entry = controller_.GetEntryAtIndex(entry_index);
3563
3564   if (page_state == entry->GetPageState())
3565     return;  // Nothing to update.
3566   entry->SetPageState(page_state);
3567   controller_.NotifyEntryChanged(entry, entry_index);
3568 }
3569
3570 void WebContentsImpl::UpdateTargetURL(int32 page_id, const GURL& url) {
3571   if (delegate_)
3572     delegate_->UpdateTargetURL(this, page_id, url);
3573 }
3574
3575 void WebContentsImpl::Close(RenderViewHost* rvh) {
3576 #if defined(OS_MACOSX)
3577   // The UI may be in an event-tracking loop, such as between the
3578   // mouse-down and mouse-up in text selection or a button click.
3579   // Defer the close until after tracking is complete, so that we
3580   // don't free objects out from under the UI.
3581   // TODO(shess): This could get more fine-grained.  For instance,
3582   // closing a tab in another window while selecting text in the
3583   // current window's Omnibox should be just fine.
3584   if (view_->IsEventTracking()) {
3585     view_->CloseTabAfterEventTracking();
3586     return;
3587   }
3588 #endif
3589
3590   // Ignore this if it comes from a RenderViewHost that we aren't showing.
3591   if (delegate_ && rvh == GetRenderViewHost())
3592     delegate_->CloseContents(this);
3593 }
3594
3595 void WebContentsImpl::SwappedOut(RenderFrameHost* rfh) {
3596   if (delegate_ && rfh->GetRenderViewHost() == GetRenderViewHost())
3597     delegate_->SwappedOut(this);
3598 }
3599
3600 void WebContentsImpl::DidDeferAfterResponseStarted(
3601     const TransitionLayerData& transition_data) {
3602 #if defined(OS_ANDROID)
3603   GetWebContentsAndroid()->DidDeferAfterResponseStarted(transition_data);
3604 #endif
3605 }
3606
3607 bool WebContentsImpl::WillHandleDeferAfterResponseStarted() {
3608 #if defined(OS_ANDROID)
3609   return GetWebContentsAndroid()->WillHandleDeferAfterResponseStarted();
3610 #else
3611   return false;
3612 #endif
3613 }
3614
3615 void WebContentsImpl::RequestMove(const gfx::Rect& new_bounds) {
3616   if (delegate_ && delegate_->IsPopupOrPanel(this))
3617     delegate_->MoveContents(this, new_bounds);
3618 }
3619
3620 void WebContentsImpl::DidStartLoading(RenderFrameHost* render_frame_host,
3621                                       bool to_different_document) {
3622   SetIsLoading(render_frame_host->GetRenderViewHost(), true,
3623                to_different_document, NULL);
3624 }
3625
3626 void WebContentsImpl::DidStopLoading(RenderFrameHost* render_frame_host) {
3627   scoped_ptr<LoadNotificationDetails> details;
3628
3629   // Use the last committed entry rather than the active one, in case a
3630   // pending entry has been created.
3631   NavigationEntry* entry = controller_.GetLastCommittedEntry();
3632   Navigator* navigator = frame_tree_.root()->navigator();
3633
3634   // An entry may not exist for a stop when loading an initial blank page or
3635   // if an iframe injected by script into a blank page finishes loading.
3636   if (entry) {
3637     base::TimeDelta elapsed =
3638         base::TimeTicks::Now() - navigator->GetCurrentLoadStart();
3639
3640     details.reset(new LoadNotificationDetails(
3641         entry->GetVirtualURL(),
3642         entry->GetTransitionType(),
3643         elapsed,
3644         &controller_,
3645         controller_.GetCurrentEntryIndex()));
3646   }
3647
3648   SetIsLoading(render_frame_host->GetRenderViewHost(), false, true,
3649                details.get());
3650 }
3651
3652 void WebContentsImpl::DidCancelLoading() {
3653   controller_.DiscardNonCommittedEntries();
3654
3655   // Update the URL display.
3656   NotifyNavigationStateChanged(INVALIDATE_TYPE_URL);
3657 }
3658
3659 void WebContentsImpl::DidAccessInitialDocument() {
3660   has_accessed_initial_document_ = true;
3661
3662   // We may have left a failed browser-initiated navigation in the address bar
3663   // to let the user edit it and try again.  Clear it now that content might
3664   // show up underneath it.
3665   if (!IsLoading() && controller_.GetPendingEntry())
3666     controller_.DiscardPendingEntry();
3667
3668   // Update the URL display.
3669   NotifyNavigationStateChanged(content::INVALIDATE_TYPE_URL);
3670 }
3671
3672 void WebContentsImpl::DidDisownOpener(RenderFrameHost* render_frame_host) {
3673   // No action is necessary if the opener has already been cleared.
3674   if (!opener_)
3675     return;
3676
3677   // Clear our opener so that future cross-process navigations don't have an
3678   // opener assigned.
3679   RemoveDestructionObserver(opener_);
3680   opener_ = NULL;
3681
3682   // Notify all swapped out RenderViewHosts for this tab.  This is important
3683   // in case we go back to them, or if another window in those processes tries
3684   // to access window.opener.
3685   GetRenderManager()->DidDisownOpener(render_frame_host);
3686 }
3687
3688 void WebContentsImpl::DocumentOnLoadCompleted(
3689     RenderFrameHost* render_frame_host) {
3690   FOR_EACH_OBSERVER(WebContentsObserver, observers_,
3691                     DocumentOnLoadCompletedInMainFrame());
3692
3693   // TODO(avi): Remove. http://crbug.com/170921
3694   NotificationService::current()->Notify(
3695       NOTIFICATION_LOAD_COMPLETED_MAIN_FRAME,
3696       Source<WebContents>(this),
3697       NotificationService::NoDetails());
3698 }
3699
3700 void WebContentsImpl::UpdateTitle(RenderFrameHost* render_frame_host,
3701                                   int32 page_id,
3702                                   const base::string16& title,
3703                                   base::i18n::TextDirection title_direction) {
3704   RenderViewHost* rvh = render_frame_host->GetRenderViewHost();
3705
3706   // If we have a title, that's a pretty good indication that we've started
3707   // getting useful data.
3708   SetNotWaitingForResponse();
3709
3710   // Try to find the navigation entry, which might not be the current one.
3711   // For example, it might be from a pending RVH for the pending entry.
3712   NavigationEntryImpl* entry = controller_.GetEntryWithPageID(
3713       rvh->GetSiteInstance(), page_id);
3714
3715   // We can handle title updates when we don't have an entry in
3716   // UpdateTitleForEntry, but only if the update is from the current RVH.
3717   // TODO(avi): Change to make decisions based on the RenderFrameHost.
3718   if (!entry && rvh != GetRenderViewHost())
3719     return;
3720
3721   // TODO(evan): make use of title_direction.
3722   // http://code.google.com/p/chromium/issues/detail?id=27094
3723   if (!UpdateTitleForEntry(entry, title))
3724     return;
3725
3726   // Broadcast notifications when the UI should be updated.
3727   if (entry == controller_.GetEntryAtOffset(0))
3728     NotifyNavigationStateChanged(INVALIDATE_TYPE_TITLE);
3729 }
3730
3731 void WebContentsImpl::UpdateEncoding(RenderFrameHost* render_frame_host,
3732                                      const std::string& encoding) {
3733   SetEncoding(encoding);
3734 }
3735
3736 void WebContentsImpl::DocumentAvailableInMainFrame(
3737     RenderViewHost* render_view_host) {
3738   FOR_EACH_OBSERVER(WebContentsObserver, observers_,
3739                     DocumentAvailableInMainFrame());
3740 }
3741 void WebContentsImpl::RouteCloseEvent(RenderViewHost* rvh) {
3742   // Tell the active RenderViewHost to run unload handlers and close, as long
3743   // as the request came from a RenderViewHost in the same BrowsingInstance.
3744   // In most cases, we receive this from a swapped out RenderViewHost.
3745   // It is possible to receive it from one that has just been swapped in,
3746   // in which case we might as well deliver the message anyway.
3747   if (rvh->GetSiteInstance()->IsRelatedSiteInstance(GetSiteInstance()))
3748     GetRenderViewHost()->ClosePage();
3749 }
3750
3751 void WebContentsImpl::RouteMessageEvent(
3752     RenderViewHost* rvh,
3753     const ViewMsg_PostMessage_Params& params) {
3754   // Only deliver the message to the active RenderViewHost if the request
3755   // came from a RenderViewHost in the same BrowsingInstance or if this
3756   // WebContents is dedicated to a browser plugin guest.
3757   // Note: This check means that an embedder could theoretically receive a
3758   // postMessage from anyone (not just its own guests). However, this is
3759   // probably not a risk for apps since other pages won't have references
3760   // to App windows.
3761   if (!rvh->GetSiteInstance()->IsRelatedSiteInstance(GetSiteInstance()) &&
3762       !GetBrowserPluginGuest() && !GetBrowserPluginEmbedder())
3763     return;
3764
3765   ViewMsg_PostMessage_Params new_params(params);
3766
3767   if (!params.message_port_ids.empty()) {
3768     MessagePortMessageFilter* message_port_message_filter =
3769         static_cast<RenderProcessHostImpl*>(GetRenderProcessHost())
3770             ->message_port_message_filter();
3771     message_port_message_filter->UpdateMessagePortsWithNewRoutes(
3772         params.message_port_ids,
3773         &new_params.new_routing_ids);
3774   }
3775
3776   // If there is a source_routing_id, translate it to the routing ID for
3777   // the equivalent swapped out RVH in the target process.  If we need
3778   // to create a swapped out RVH for the source tab, we create its opener
3779   // chain as well, since those will also be accessible to the target page.
3780   if (new_params.source_routing_id != MSG_ROUTING_NONE) {
3781     // Try to look up the WebContents for the source page.
3782     WebContentsImpl* source_contents = NULL;
3783     RenderViewHostImpl* source_rvh = RenderViewHostImpl::FromID(
3784         rvh->GetProcess()->GetID(), params.source_routing_id);
3785     if (source_rvh) {
3786       source_contents = static_cast<WebContentsImpl*>(
3787           source_rvh->GetDelegate()->GetAsWebContents());
3788     }
3789
3790     if (source_contents) {
3791       if (GetBrowserPluginGuest()) {
3792         // We create a swapped out RenderView for the embedder in the guest's
3793         // render process but we intentionally do not expose the embedder's
3794         // opener chain to it.
3795         new_params.source_routing_id =
3796             source_contents->CreateSwappedOutRenderView(GetSiteInstance());
3797       } else {
3798         new_params.source_routing_id =
3799             source_contents->CreateOpenerRenderViews(GetSiteInstance());
3800       }
3801     } else {
3802       // We couldn't find it, so don't pass a source frame.
3803       new_params.source_routing_id = MSG_ROUTING_NONE;
3804     }
3805   }
3806
3807   // In most cases, we receive this from a swapped out RenderViewHost.
3808   // It is possible to receive it from one that has just been swapped in,
3809   // in which case we might as well deliver the message anyway.
3810   Send(new ViewMsg_PostMessageEvent(GetRoutingID(), new_params));
3811 }
3812
3813 bool WebContentsImpl::AddMessageToConsole(int32 level,
3814                                           const base::string16& message,
3815                                           int32 line_no,
3816                                           const base::string16& source_id) {
3817   if (!delegate_)
3818     return false;
3819   return delegate_->AddMessageToConsole(this, level, message, line_no,
3820                                         source_id);
3821 }
3822
3823 WebPreferences WebContentsImpl::ComputeWebkitPrefs() {
3824   // We want to base the page config off of the actual URL, rather than the
3825   // virtual URL.
3826   // TODO(nasko): Investigate how to remove the GetActiveEntry usage here,
3827   // as it is deprecated and can be out of sync with GetRenderViewHost().
3828   GURL url = controller_.GetActiveEntry()
3829       ? controller_.GetActiveEntry()->GetURL() : GURL::EmptyGURL();
3830
3831   return GetRenderManager()->current_host()->ComputeWebkitPrefs(url);
3832 }
3833
3834 int WebContentsImpl::CreateSwappedOutRenderView(
3835     SiteInstance* instance) {
3836   return GetRenderManager()->CreateRenderFrame(
3837       instance, MSG_ROUTING_NONE, true, true, true);
3838 }
3839
3840 void WebContentsImpl::OnUserGesture() {
3841   // Notify observers.
3842   FOR_EACH_OBSERVER(WebContentsObserver, observers_, DidGetUserGesture());
3843
3844   ResourceDispatcherHostImpl* rdh = ResourceDispatcherHostImpl::Get();
3845   if (rdh)  // NULL in unittests.
3846     rdh->OnUserGesture(this);
3847 }
3848
3849 void WebContentsImpl::OnIgnoredUIEvent() {
3850   // Notify observers.
3851   FOR_EACH_OBSERVER(WebContentsObserver, observers_, DidGetIgnoredUIEvent());
3852 }
3853
3854 void WebContentsImpl::RendererUnresponsive(RenderViewHost* rvh,
3855                                            bool is_during_beforeunload,
3856                                            bool is_during_unload) {
3857   // Don't show hung renderer dialog for a swapped out RVH.
3858   if (rvh != GetRenderViewHost())
3859     return;
3860
3861   RenderViewHostImpl* rvhi = static_cast<RenderViewHostImpl*>(rvh);
3862
3863   // Ignore renderer unresponsive event if debugger is attached to the tab
3864   // since the event may be a result of the renderer sitting on a breakpoint.
3865   // See http://crbug.com/65458
3866   if (DevToolsAgentHost::IsDebuggerAttached(this))
3867     return;
3868
3869   if (is_during_beforeunload || is_during_unload) {
3870     // Hang occurred while firing the beforeunload/unload handler.
3871     // Pretend the handler fired so tab closing continues as if it had.
3872     rvhi->set_sudden_termination_allowed(true);
3873
3874     if (!GetRenderManager()->ShouldCloseTabOnUnresponsiveRenderer())
3875       return;
3876
3877     // If the tab hangs in the beforeunload/unload handler there's really
3878     // nothing we can do to recover. If the hang is in the beforeunload handler,
3879     // pretend the beforeunload listeners have all fired and allow the delegate
3880     // to continue closing; the user will not have the option of cancelling the
3881     // close. Otherwise, pretend the unload listeners have all fired and close
3882     // the tab.
3883     bool close = true;
3884     if (is_during_beforeunload && delegate_) {
3885       delegate_->BeforeUnloadFired(this, true, &close);
3886     }
3887     if (close)
3888       Close(rvh);
3889     return;
3890   }
3891
3892   if (!GetRenderViewHostImpl() || !GetRenderViewHostImpl()->IsRenderViewLive())
3893     return;
3894
3895   if (delegate_)
3896     delegate_->RendererUnresponsive(this);
3897 }
3898
3899 void WebContentsImpl::RendererResponsive(RenderViewHost* render_view_host) {
3900   if (delegate_)
3901     delegate_->RendererResponsive(this);
3902 }
3903
3904 void WebContentsImpl::LoadStateChanged(
3905     const GURL& url,
3906     const net::LoadStateWithParam& load_state,
3907     uint64 upload_position,
3908     uint64 upload_size) {
3909   load_state_ = load_state;
3910   upload_position_ = upload_position;
3911   upload_size_ = upload_size;
3912   load_state_host_ = net::IDNToUnicode(url.host(),
3913       GetContentClient()->browser()->GetAcceptLangs(
3914           GetBrowserContext()));
3915   if (load_state_.state == net::LOAD_STATE_READING_RESPONSE)
3916     SetNotWaitingForResponse();
3917   if (IsLoading()) {
3918     NotifyNavigationStateChanged(static_cast<InvalidateTypes>(
3919         INVALIDATE_TYPE_LOAD | INVALIDATE_TYPE_TAB));
3920   }
3921 }
3922
3923 void WebContentsImpl::BeforeUnloadFiredFromRenderManager(
3924     bool proceed, const base::TimeTicks& proceed_time,
3925     bool* proceed_to_fire_unload) {
3926   FOR_EACH_OBSERVER(WebContentsObserver, observers_,
3927                     BeforeUnloadFired(proceed_time));
3928   if (delegate_)
3929     delegate_->BeforeUnloadFired(this, proceed, proceed_to_fire_unload);
3930   // Note: |this| might be deleted at this point.
3931 }
3932
3933 void WebContentsImpl::RenderProcessGoneFromRenderManager(
3934     RenderViewHost* render_view_host) {
3935   DCHECK(crashed_status_ != base::TERMINATION_STATUS_STILL_RUNNING);
3936   RenderViewTerminated(render_view_host, crashed_status_, crashed_error_code_);
3937 }
3938
3939 void WebContentsImpl::UpdateRenderViewSizeForRenderManager() {
3940   // TODO(brettw) this is a hack. See WebContentsView::SizeContents.
3941   gfx::Size size = GetSizeForNewRenderView();
3942   // 0x0 isn't a valid window size (minimal window size is 1x1) but it may be
3943   // here during container initialization and normal window size will be set
3944   // later. In case of tab duplication this resizing to 0x0 prevents setting
3945   // normal size later so just ignore it.
3946   if (!size.IsEmpty())
3947     view_->SizeContents(size);
3948 }
3949
3950 void WebContentsImpl::CancelModalDialogsForRenderManager() {
3951   // We need to cancel modal dialogs when doing a process swap, since the load
3952   // deferrer would prevent us from swapping out.
3953   if (dialog_manager_)
3954     dialog_manager_->CancelActiveAndPendingDialogs(this);
3955 }
3956
3957 void WebContentsImpl::NotifySwappedFromRenderManager(RenderFrameHost* old_host,
3958                                                      RenderFrameHost* new_host,
3959                                                      bool is_main_frame) {
3960   if (is_main_frame) {
3961     NotifyViewSwapped(old_host ? old_host->GetRenderViewHost() : NULL,
3962                       new_host->GetRenderViewHost());
3963
3964     // Make sure the visible RVH reflects the new delegate's preferences.
3965     if (delegate_)
3966       view_->SetOverscrollControllerEnabled(CanOverscrollContent());
3967
3968     view_->RenderViewSwappedIn(new_host->GetRenderViewHost());
3969   }
3970
3971   NotifyFrameSwapped(old_host, new_host);
3972 }
3973
3974 int WebContentsImpl::CreateOpenerRenderViewsForRenderManager(
3975     SiteInstance* instance) {
3976   if (!opener_)
3977     return MSG_ROUTING_NONE;
3978
3979   // Recursively create RenderViews for anything else in the opener chain.
3980   return opener_->CreateOpenerRenderViews(instance);
3981 }
3982
3983 int WebContentsImpl::CreateOpenerRenderViews(SiteInstance* instance) {
3984   int opener_route_id = MSG_ROUTING_NONE;
3985
3986   // If this tab has an opener, ensure it has a RenderView in the given
3987   // SiteInstance as well.
3988   if (opener_)
3989     opener_route_id = opener_->CreateOpenerRenderViews(instance);
3990
3991   // If any of the renderers (current, pending, or swapped out) for this
3992   // WebContents has the same SiteInstance, use it.
3993   if (GetRenderManager()->current_host()->GetSiteInstance() == instance)
3994     return GetRenderManager()->current_host()->GetRoutingID();
3995
3996   if (GetRenderManager()->pending_render_view_host() &&
3997       GetRenderManager()->pending_render_view_host()->GetSiteInstance() ==
3998           instance)
3999     return GetRenderManager()->pending_render_view_host()->GetRoutingID();
4000
4001   RenderViewHostImpl* rvh = GetRenderManager()->GetSwappedOutRenderViewHost(
4002       instance);
4003   if (rvh)
4004     return rvh->GetRoutingID();
4005
4006   // Create a swapped out RenderView in the given SiteInstance if none exists,
4007   // setting its opener to the given route_id.  Return the new view's route_id.
4008   return GetRenderManager()->CreateRenderFrame(
4009       instance, opener_route_id, true, true, true);
4010 }
4011
4012 NavigationControllerImpl& WebContentsImpl::GetControllerForRenderManager() {
4013   return GetController();
4014 }
4015
4016 WebUIImpl* WebContentsImpl::CreateWebUIForRenderManager(const GURL& url) {
4017   return static_cast<WebUIImpl*>(CreateWebUI(url));
4018 }
4019
4020 NavigationEntry*
4021     WebContentsImpl::GetLastCommittedNavigationEntryForRenderManager() {
4022   return controller_.GetLastCommittedEntry();
4023 }
4024
4025 bool WebContentsImpl::CreateRenderViewForRenderManager(
4026     RenderViewHost* render_view_host,
4027     int opener_route_id,
4028     int proxy_routing_id,
4029     bool for_main_frame_navigation) {
4030   TRACE_EVENT0("browser", "WebContentsImpl::CreateRenderViewForRenderManager");
4031   // Can be NULL during tests.
4032   RenderWidgetHostViewBase* rwh_view;
4033   // TODO(kenrb): RenderWidgetHostViewChildFrame special casing is temporary
4034   // until RenderWidgetHost is attached to RenderFrameHost. We need to special
4035   // case this because RWH is still a base class of RenderViewHost, and child
4036   // frame RWHVs are unique in that they do not have their own WebContents.
4037   if (!for_main_frame_navigation) {
4038     RenderWidgetHostViewChildFrame* rwh_view_child =
4039         new RenderWidgetHostViewChildFrame(render_view_host);
4040     rwh_view = rwh_view_child;
4041   } else {
4042     rwh_view = view_->CreateViewForWidget(render_view_host);
4043   }
4044
4045   // Now that the RenderView has been created, we need to tell it its size.
4046   if (rwh_view)
4047     rwh_view->SetSize(GetSizeForNewRenderView());
4048
4049   // Make sure we use the correct starting page_id in the new RenderView.
4050   UpdateMaxPageIDIfNecessary(render_view_host);
4051   int32 max_page_id =
4052       GetMaxPageIDForSiteInstance(render_view_host->GetSiteInstance());
4053
4054   if (!static_cast<RenderViewHostImpl*>(
4055           render_view_host)->CreateRenderView(base::string16(),
4056                                               opener_route_id,
4057                                               proxy_routing_id,
4058                                               max_page_id,
4059                                               created_with_opener_)) {
4060     return false;
4061   }
4062
4063 #if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
4064   // Force a ViewMsg_Resize to be sent, needed to make plugins show up on
4065   // linux. See crbug.com/83941.
4066   if (rwh_view) {
4067     if (RenderWidgetHost* render_widget_host = rwh_view->GetRenderWidgetHost())
4068       render_widget_host->WasResized();
4069   }
4070 #endif
4071
4072   return true;
4073 }
4074
4075 bool WebContentsImpl::CreateRenderFrameForRenderManager(
4076     RenderFrameHost* render_frame_host,
4077     int parent_routing_id) {
4078   TRACE_EVENT0("browser", "WebContentsImpl::CreateRenderFrameForRenderManager");
4079
4080   RenderFrameHostImpl* rfh =
4081       static_cast<RenderFrameHostImpl*>(render_frame_host);
4082   if (!rfh->CreateRenderFrame(parent_routing_id))
4083     return false;
4084
4085   // TODO(nasko): When RenderWidgetHost is owned by RenderFrameHost, the passed
4086   // RenderFrameHost will have to be associated with the appropriate
4087   // RenderWidgetHostView or a new one should be created here.
4088
4089   return true;
4090 }
4091
4092 #if defined(OS_ANDROID)
4093
4094 base::android::ScopedJavaLocalRef<jobject>
4095 WebContentsImpl::GetJavaWebContents() {
4096   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
4097   return GetWebContentsAndroid()->GetJavaObject();
4098 }
4099
4100 WebContentsAndroid* WebContentsImpl::GetWebContentsAndroid() {
4101   WebContentsAndroid* web_contents_android =
4102       static_cast<WebContentsAndroid*>(GetUserData(kWebContentsAndroidKey));
4103   if (!web_contents_android) {
4104     web_contents_android = new WebContentsAndroid(this);
4105     SetUserData(kWebContentsAndroidKey, web_contents_android);
4106   }
4107   return web_contents_android;
4108 }
4109
4110 bool WebContentsImpl::CreateRenderViewForInitialEmptyDocument() {
4111   return CreateRenderViewForRenderManager(GetRenderViewHost(),
4112                                           MSG_ROUTING_NONE,
4113                                           MSG_ROUTING_NONE,
4114                                           true);
4115 }
4116
4117 #elif defined(OS_MACOSX)
4118
4119 void WebContentsImpl::SetAllowOtherViews(bool allow) {
4120   view_->SetAllowOtherViews(allow);
4121 }
4122
4123 bool WebContentsImpl::GetAllowOtherViews() {
4124   return view_->GetAllowOtherViews();
4125 }
4126
4127 #endif
4128
4129 void WebContentsImpl::OnDialogClosed(int render_process_id,
4130                                      int render_frame_id,
4131                                      IPC::Message* reply_msg,
4132                                      bool dialog_was_suppressed,
4133                                      bool success,
4134                                      const base::string16& user_input) {
4135   RenderFrameHostImpl* rfh = RenderFrameHostImpl::FromID(render_process_id,
4136                                                          render_frame_id);
4137   last_dialog_suppressed_ = dialog_was_suppressed;
4138
4139   if (is_showing_before_unload_dialog_ && !success) {
4140     // If a beforeunload dialog is canceled, we need to stop the throbber from
4141     // spinning, since we forced it to start spinning in Navigate.
4142     if (rfh)
4143       DidStopLoading(rfh);
4144     controller_.DiscardNonCommittedEntries();
4145
4146     FOR_EACH_OBSERVER(WebContentsObserver, observers_,
4147                       BeforeUnloadDialogCancelled());
4148   }
4149
4150   is_showing_before_unload_dialog_ = false;
4151   if (rfh) {
4152     rfh->JavaScriptDialogClosed(reply_msg, success, user_input,
4153                                 dialog_was_suppressed);
4154   } else {
4155     // Don't leak the sync IPC reply if the RFH or process is gone.
4156     delete reply_msg;
4157   }
4158 }
4159
4160 void WebContentsImpl::SetEncoding(const std::string& encoding) {
4161   if (encoding == last_reported_encoding_)
4162     return;
4163   last_reported_encoding_ = encoding;
4164
4165   canonical_encoding_ = GetContentClient()->browser()->
4166       GetCanonicalEncodingNameByAliasName(encoding);
4167 }
4168
4169 void WebContentsImpl::CreateViewAndSetSizeForRVH(RenderViewHost* rvh) {
4170   RenderWidgetHostViewBase* rwh_view = view_->CreateViewForWidget(rvh);
4171   // Can be NULL during tests.
4172   if (rwh_view)
4173     rwh_view->SetSize(GetContainerBounds().size());
4174 }
4175
4176 bool WebContentsImpl::IsHidden() {
4177   return capturer_count_ == 0 && !should_normally_be_visible_;
4178 }
4179
4180 RenderFrameHostManager* WebContentsImpl::GetRenderManager() const {
4181   return frame_tree_.root()->render_manager();
4182 }
4183
4184 RenderViewHostImpl* WebContentsImpl::GetRenderViewHostImpl() {
4185   return static_cast<RenderViewHostImpl*>(GetRenderViewHost());
4186 }
4187
4188 BrowserPluginGuest* WebContentsImpl::GetBrowserPluginGuest() const {
4189   return browser_plugin_guest_.get();
4190 }
4191
4192 void WebContentsImpl::SetBrowserPluginGuest(BrowserPluginGuest* guest) {
4193   CHECK(!browser_plugin_guest_);
4194   browser_plugin_guest_.reset(guest);
4195 }
4196
4197 BrowserPluginEmbedder* WebContentsImpl::GetBrowserPluginEmbedder() const {
4198   return browser_plugin_embedder_.get();
4199 }
4200
4201 void WebContentsImpl::ClearPowerSaveBlockers(
4202     RenderFrameHost* render_frame_host) {
4203 #if !defined(OS_CHROMEOS)
4204   uintptr_t key = reinterpret_cast<uintptr_t>(render_frame_host);
4205   scoped_ptr<PowerSaveBlockerMapEntry> map_entry =
4206       power_save_blockers_.take_and_erase(key);
4207   if (map_entry)
4208     map_entry->clear();
4209 #endif
4210 }
4211
4212 void WebContentsImpl::ClearAllPowerSaveBlockers() {
4213 #if !defined(OS_CHROMEOS)
4214   power_save_blockers_.clear();
4215 #endif
4216 }
4217
4218 gfx::Size WebContentsImpl::GetSizeForNewRenderView() {
4219   gfx::Size size;
4220   if (delegate_)
4221     size = delegate_->GetSizeForNewRenderView(this);
4222   if (size.IsEmpty())
4223     size = GetContainerBounds().size();
4224   return size;
4225 }
4226
4227 void WebContentsImpl::OnFrameRemoved(RenderFrameHost* render_frame_host) {
4228   FOR_EACH_OBSERVER(
4229       WebContentsObserver, observers_, FrameDetached(render_frame_host));
4230 }
4231
4232 void WebContentsImpl::OnPreferredSizeChanged(const gfx::Size& old_size) {
4233   if (!delegate_)
4234     return;
4235   const gfx::Size new_size = GetPreferredSize();
4236   if (new_size != old_size)
4237     delegate_->UpdatePreferredSize(this, new_size);
4238 }
4239
4240 void WebContentsImpl::ResumeResponseDeferredAtStart() {
4241   FrameTreeNode* node = frame_tree_.root();
4242   node->render_manager()->ResumeResponseDeferredAtStart();
4243 }
4244
4245 void WebContentsImpl::SetForceDisableOverscrollContent(bool force_disable) {
4246   force_disable_overscroll_content_ = force_disable;
4247   if (view_)
4248     view_->SetOverscrollControllerEnabled(CanOverscrollContent());
4249 }
4250
4251 }  // namespace content