Start moving core pieces of Chrome multi-process code to src\content.

chrome/browser/tab_contents/tab_contents.cc

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "chrome/browser/tab_contents/tab_contents.h"
-
-#include <cmath>
-
-#include "base/auto_reset.h"
-#include "base/metrics/histogram.h"
-#include "base/metrics/stats_counters.h"
-#include "base/string16.h"
-#include "base/string_util.h"
-#include "base/time.h"
-#include "base/utf_string_conversions.h"
-#include "chrome/browser/autocomplete_history_manager.h"
-#include "chrome/browser/autofill/autofill_manager.h"
-#include "chrome/browser/blocked_content_container.h"
-#include "chrome/browser/browser_process.h"
-#include "chrome/browser/browser_shutdown.h"
-#include "chrome/browser/character_encoding.h"
-#include "chrome/browser/child_process_security_policy.h"
-#include "chrome/browser/content_settings/content_settings_details.h"
-#include "chrome/browser/content_settings/host_content_settings_map.h"
-#include "chrome/browser/debugger/devtools_manager.h"
-#include "chrome/browser/defaults.h"
-#include "chrome/browser/desktop_notification_handler.h"
-#include "chrome/browser/dom_operation_notification_details.h"
-#include "chrome/browser/download/download_item_model.h"
-#include "chrome/browser/download/download_manager.h"
-#include "chrome/browser/download/download_request_limiter.h"
-#include "chrome/browser/extensions/extension_service.h"
-#include "chrome/browser/external_protocol_handler.h"
-#include "chrome/browser/favicon_service.h"
-#include "chrome/browser/file_select_helper.h"
-#include "chrome/browser/google/google_util.h"
-#include "chrome/browser/history/history.h"
-#include "chrome/browser/history/history_types.h"
-#include "chrome/browser/history/top_sites.h"
-#include "chrome/browser/host_zoom_map.h"
-#include "chrome/browser/hung_renderer_dialog.h"
-#include "chrome/browser/in_process_webkit/session_storage_namespace.h"
-#include "chrome/browser/load_from_memory_cache_details.h"
-#include "chrome/browser/load_notification_details.h"
-#include "chrome/browser/metrics/metric_event_duration_details.h"
-#include "chrome/browser/metrics/user_metrics.h"
-#include "chrome/browser/modal_html_dialog_delegate.h"
-#include "chrome/browser/omnibox_search_hint.h"
-#include "chrome/browser/pdf_unsupported_feature.h"
-#include "chrome/browser/platform_util.h"
-#include "chrome/browser/plugin_observer.h"
-#include "chrome/browser/prefs/pref_service.h"
-#include "chrome/browser/prerender/prerender_manager.h"
-#include "chrome/browser/prerender/prerender_plt_recorder.h"
-#include "chrome/browser/printing/print_preview_message_handler.h"
-#include "chrome/browser/printing/print_preview_tab_controller.h"
-#include "chrome/browser/printing/print_view_manager.h"
-#include "chrome/browser/profiles/profile.h"
-#include "chrome/browser/renderer_host/render_process_host.h"
-#include "chrome/browser/renderer_host/render_view_host.h"
-#include "chrome/browser/renderer_host/render_widget_host_view.h"
-#include "chrome/browser/renderer_host/resource_request_details.h"
-#include "chrome/browser/renderer_host/site_instance.h"
-#include "chrome/browser/renderer_host/web_cache_manager.h"
-#include "chrome/browser/renderer_preferences_util.h"
-#include "chrome/browser/safe_browsing/client_side_detection_host.h"
-#include "chrome/browser/sessions/session_types.h"
-#include "chrome/browser/tab_contents/infobar_delegate.h"
-#include "chrome/browser/tab_contents/interstitial_page.h"
-#include "chrome/browser/tab_contents/navigation_entry.h"
-#include "chrome/browser/tab_contents/provisional_load_details.h"
-#include "chrome/browser/tab_contents/tab_contents_delegate.h"
-#include "chrome/browser/tab_contents/tab_contents_observer.h"
-#include "chrome/browser/tab_contents/tab_contents_ssl_helper.h"
-#include "chrome/browser/tab_contents/tab_contents_view.h"
-#include "chrome/browser/tab_contents/thumbnail_generator.h"
-#include "chrome/browser/translate/page_translated_details.h"
-#include "chrome/browser/ui/app_modal_dialogs/message_box_handler.h"
-#include "chrome/browser/webui/web_ui.h"
-#include "chrome/common/bindings_policy.h"
-#include "chrome/common/chrome_switches.h"
-#include "chrome/common/content_restriction.h"
-#include "chrome/common/extensions/extension.h"
-#include "chrome/common/extensions/extension_action.h"
-#include "chrome/common/extensions/extension_icon_set.h"
-#include "chrome/common/extensions/extension_resource.h"
-#include "chrome/common/extensions/url_pattern.h"
-#include "chrome/common/navigation_types.h"
-#include "chrome/common/net/url_request_context_getter.h"
-#include "chrome/common/notification_service.h"
-#include "chrome/common/pref_names.h"
-#include "chrome/common/render_messages.h"
-#include "chrome/common/render_messages_params.h"
-#include "chrome/common/url_constants.h"
-#include "grit/chromium_strings.h"
-#include "grit/generated_resources.h"
-#include "grit/locale_settings.h"
-#include "grit/platform_locale_settings.h"
-#include "grit/theme_resources.h"
-#include "net/base/net_util.h"
-#include "net/base/registry_controlled_domain.h"
-#include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
-#include "ui/base/l10n/l10n_util.h"
-#include "ui/base/resource/resource_bundle.h"
-#include "ui/gfx/codec/png_codec.h"
-#include "webkit/glue/password_form.h"
-#include "webkit/glue/webpreferences.h"
-
-#if defined(OS_MACOSX)
-#include "app/surface/io_surface_support_mac.h"
-#endif  // defined(OS_MACOSX)
-
-#if defined(OS_CHROMEOS)
-#include "chrome/browser/chromeos/locale_change_guard.h"
-#endif  // defined(OS_CHROMEOS)
-
-// Cross-Site Navigations
-//
-// If a TabContents is told to navigate to a different web site (as determined
-// by SiteInstance), it will replace its current RenderViewHost with a new
-// RenderViewHost dedicated to the new SiteInstance.  This works as follows:
-//
-// - Navigate determines whether the destination is cross-site, and if so,
-//   it creates a pending_render_view_host_ and moves into the PENDING
-//   RendererState.
-// - The pending RVH is "suspended," so that no navigation messages are sent to
-//   its renderer until the onbeforeunload JavaScript handler has a chance to
-//   run in the current RVH.
-// - The pending RVH tells CrossSiteRequestManager (a thread-safe singleton)
-//   that it has a pending cross-site request.  ResourceDispatcherHost will
-//   check for this when the response arrives.
-// - The current RVH runs its onbeforeunload handler.  If it returns false, we
-//   cancel all the pending logic and go back to NORMAL.  Otherwise we allow
-//   the pending RVH to send the navigation request to its renderer.
-// - ResourceDispatcherHost receives a ResourceRequest on the IO thread.  It
-//   checks CrossSiteRequestManager to see that the RVH responsible has a
-//   pending cross-site request, and then installs a CrossSiteEventHandler.
-// - When RDH receives a response, the BufferedEventHandler determines whether
-//   it is a download.  If so, it sends a message to the new renderer causing
-//   it to cancel the request, and the download proceeds in the download
-//   thread.  For now, we stay in a PENDING state (with a pending RVH) until
-//   the next DidNavigate event for this TabContents.  This isn't ideal, but it
-//   doesn't affect any functionality.
-// - After RDH receives a response and determines that it is safe and not a
-//   download, it pauses the response to first run the old page's onunload
-//   handler.  It does this by asynchronously calling the OnCrossSiteResponse
-//   method of TabContents on the UI thread, which sends a ClosePage message
-//   to the current RVH.
-// - Once the onunload handler is finished, a ClosePage_ACK message is sent to
-//   the ResourceDispatcherHost, who unpauses the response.  Data is then sent
-//   to the pending RVH.
-// - The pending renderer sends a FrameNavigate message that invokes the
-//   DidNavigate method.  This replaces the current RVH with the
-//   pending RVH and goes back to the NORMAL RendererState.
-
-namespace {
-
-// Amount of time we wait between when a key event is received and the renderer
-// is queried for its state and pushed to the NavigationEntry.
-const int kQueryStateDelay = 5000;
-
-const int kSyncWaitDelay = 40;
-
-// If another javascript message box is displayed within
-// kJavascriptMessageExpectedDelay of a previous javascript message box being
-// dismissed, display an option to suppress future message boxes from this
-// contents.
-const int kJavascriptMessageExpectedDelay = 1000;
-
-// The list of prefs we want to observe.
-const char* kPrefsToObserve[] = {
-  prefs::kAlternateErrorPagesEnabled,
-  prefs::kDefaultZoomLevel,
-  prefs::kWebKitJavaEnabled,
-  prefs::kWebKitJavascriptEnabled,
-  prefs::kWebKitLoadsImagesAutomatically,
-  prefs::kWebKitPluginsEnabled,
-  prefs::kWebKitUsesUniversalDetector,
-  prefs::kWebKitSerifFontFamily,
-  prefs::kWebKitSansSerifFontFamily,
-  prefs::kWebKitFixedFontFamily,
-  prefs::kWebKitDefaultFontSize,
-  prefs::kWebKitDefaultFixedFontSize,
-  prefs::kWebKitMinimumFontSize,
-  prefs::kWebKitMinimumLogicalFontSize,
-  prefs::kWebkitTabsToLinks,
-  prefs::kDefaultCharset
-  // kWebKitStandardFontIsSerif needs to be added
-  // if we let users pick which font to use, serif or sans-serif when
-  // no font is specified or a CSS generic family (serif or sans-serif)
-  // is not specified.
-};
-
-const int kPrefsToObserveLength = arraysize(kPrefsToObserve);
-
-#if defined(OS_WIN)
-
-BOOL CALLBACK InvalidateWindow(HWND hwnd, LPARAM lparam) {
-  // Note: erase is required to properly paint some widgets borders. This can
-  // be seen with textfields.
-  InvalidateRect(hwnd, NULL, TRUE);
-  return TRUE;
-}
-#endif
-
-ViewMsg_Navigate_Params::NavigationType GetNavigationType(
-    Profile* profile, const NavigationEntry& entry,
-    NavigationController::ReloadType reload_type) {
-  switch (reload_type) {
-    case NavigationController::RELOAD:
-      return ViewMsg_Navigate_Params::RELOAD;
-    case NavigationController::RELOAD_IGNORING_CACHE:
-      return ViewMsg_Navigate_Params::RELOAD_IGNORING_CACHE;
-    case NavigationController::NO_RELOAD:
-      break;  // Fall through to rest of function.
-  }
-
-  if (entry.restore_type() == NavigationEntry::RESTORE_LAST_SESSION &&
-      profile->DidLastSessionExitCleanly())
-    return ViewMsg_Navigate_Params::RESTORE;
-
-  return ViewMsg_Navigate_Params::NORMAL;
-}
-
-void MakeNavigateParams(const NavigationEntry& entry,
-                        const NavigationController& controller,
-                        NavigationController::ReloadType reload_type,
-                        ViewMsg_Navigate_Params* params) {
-  params->page_id = entry.page_id();
-  params->pending_history_list_offset = controller.GetIndexOfEntry(&entry);
-  params->current_history_list_offset = controller.last_committed_entry_index();
-  params->current_history_list_length = controller.entry_count();
-  params->url = entry.url();
-  params->referrer = entry.referrer();
-  params->transition = entry.transition_type();
-  params->state = entry.content_state();
-  params->navigation_type =
-      GetNavigationType(controller.profile(), entry, reload_type);
-  params->request_time = base::Time::Now();
-}
-
-}  // namespace
-
-
-// TabContents ----------------------------------------------------------------
-
-TabContents::TabContents(Profile* profile,
-                         SiteInstance* site_instance,
-                         int routing_id,
-                         const TabContents* base_tab_contents,
-                         SessionStorageNamespace* session_storage_namespace)
-    : delegate_(NULL),
-      ALLOW_THIS_IN_INITIALIZER_LIST(controller_(
-          this, profile, session_storage_namespace)),
-      ALLOW_THIS_IN_INITIALIZER_LIST(view_(
-          TabContentsView::Create(this))),
-      ALLOW_THIS_IN_INITIALIZER_LIST(render_manager_(this, this)),
-      bookmark_drag_(NULL),
-      is_loading_(false),
-      crashed_status_(base::TERMINATION_STATUS_STILL_RUNNING),
-      crashed_error_code_(0),
-      waiting_for_response_(false),
-      max_page_id_(-1),
-      load_state_(net::LOAD_STATE_IDLE),
-      upload_size_(0),
-      upload_position_(0),
-      received_page_title_(false),
-      blocked_contents_(NULL),
-      all_contents_blocked_(false),
-      dont_notify_render_view_(false),
-      displayed_insecure_content_(false),
-      extension_app_(NULL),
-      capturing_contents_(false),
-      is_being_destroyed_(false),
-      notify_disconnection_(false),
-#if defined(OS_WIN)
-      message_box_active_(CreateEvent(NULL, TRUE, FALSE, NULL)),
-#endif
-      suppress_javascript_messages_(false),
-      is_showing_before_unload_dialog_(false),
-      opener_web_ui_type_(WebUIFactory::kNoWebUI),
-      language_state_(&controller_),
-      closed_by_user_gesture_(false),
-      minimum_zoom_percent_(
-          static_cast<int>(WebKit::WebView::minTextSizeMultiplier * 100)),
-      maximum_zoom_percent_(
-          static_cast<int>(WebKit::WebView::maxTextSizeMultiplier * 100)),
-      temporary_zoom_settings_(false),
-      content_restrictions_(0) {
-  renderer_preferences_util::UpdateFromSystemSettings(
-      &renderer_preferences_, profile);
-
-  content_settings_delegate_.reset(
-      new TabSpecificContentSettings(this, profile));
-
-  render_manager_.Init(profile, site_instance, routing_id);
-
-  // We have the initial size of the view be based on the size of the passed in
-  // tab contents (normally a tab from the same window).
-  view_->CreateView(base_tab_contents ?
-      base_tab_contents->view()->GetContainerSize() : gfx::Size());
-
-  // Register for notifications about all interested prefs change.
-  PrefService* prefs = profile->GetPrefs();
-  pref_change_registrar_.Init(prefs);
-  if (prefs) {
-    for (int i = 0; i < kPrefsToObserveLength; ++i)
-      pref_change_registrar_.Add(kPrefsToObserve[i], this);
-  }
-
-  registrar_.Add(this, NotificationType::RENDER_WIDGET_HOST_DESTROYED,
-                 NotificationService::AllSources());
-#if defined(OS_LINUX)
-  registrar_.Add(this, NotificationType::BROWSER_THEME_CHANGED,
-                 NotificationService::AllSources());
-#endif
-
-  registrar_.Add(this, NotificationType::USER_STYLE_SHEET_UPDATED,
-                 NotificationService::AllSources());
-
-  // Register for notifications about content setting changes.
-  registrar_.Add(this, NotificationType::CONTENT_SETTINGS_CHANGED,
-                 NotificationService::AllSources());
-
-  // Listen for extension changes so we can update extension_for_current_page_.
-  registrar_.Add(this, NotificationType::EXTENSION_LOADED,
-                 NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::EXTENSION_UNLOADED,
-                 NotificationService::AllSources());
-
-  // Listen for Google URL changes
-  registrar_.Add(this, NotificationType::GOOGLE_URL_UPDATED,
-                 NotificationService::AllSources());
-
-  // Set-up the showing of the omnibox search infobar if applicable.
-  if (OmniboxSearchHint::IsEnabled(profile))
-    omnibox_search_hint_.reset(new OmniboxSearchHint(this));
-
-  // Can only add observers after render_manager_.Init() is called, since that's
-  // what sets up the render_view_host which TabContentObserver's constructor
-  // uses to get the routing_id.
-  AddObservers();
-}
-
-TabContents::~TabContents() {
-  is_being_destroyed_ = true;
-
-  // We don't want any notifications while we're running our destructor.
-  registrar_.RemoveAll();
-  pref_change_registrar_.RemoveAll();
-
-  NotifyDisconnected();
-  hung_renderer_dialog::HideForTabContents(this);
-
-  // First cleanly close all child windows.
-  // TODO(mpcomplete): handle case if MaybeCloseChildWindows() already asked
-  // some of these to close.  CloseWindows is async, so it might get called
-  // twice before it runs.
-  CloseConstrainedWindows();
-
-  // Close all blocked contents.
-  if (blocked_contents_)
-    blocked_contents_->Destroy();
-
-  // Notify any observer that have a reference on this tab contents.
-  NotificationService::current()->Notify(
-      NotificationType::TAB_CONTENTS_DESTROYED,
-      Source<TabContents>(this),
-      NotificationService::NoDetails());
-
-  // Notify any lasting InfobarDelegates that have not yet been removed that
-  // whatever infobar they were handling in this TabContents has closed,
-  // because the TabContents is going away entirely.
-  // This must happen after the TAB_CONTENTS_DESTROYED notification as the
-  // notification may trigger infobars calls that access their delegate. (and
-  // some implementations of InfoBarDelegate do delete themselves on
-  // InfoBarClosed()).
-  for (size_t i = 0; i < infobar_count(); ++i) {
-    InfoBarDelegate* delegate = GetInfoBarDelegateAt(i);
-    delegate->InfoBarClosed();
-  }
-  infobar_delegates_.clear();
-
-  // TODO(brettw) this should be moved to the view.
-#if defined(OS_WIN)
-  // If we still have a window handle, destroy it. GetNativeView can return
-  // NULL if this contents was part of a window that closed.
-  if (GetNativeView()) {
-    RenderViewHost* host = render_view_host();
-    if (host && host->view()) {
-      host->view()->WillWmDestroy();
-    }
-    ::DestroyWindow(GetNativeView());
-  }
-#endif
-
-  // OnCloseStarted isn't called in unit tests.
-  if (!tab_close_start_time_.is_null()) {
-    UMA_HISTOGRAM_TIMES("Tab.Close",
-        base::TimeTicks::Now() - tab_close_start_time_);
-  }
-
-  FOR_EACH_OBSERVER(TabContentsObserver, observers_, set_tab_contents(NULL));
-}
-
-void TabContents::AddObservers() {
-  printing_.reset(new printing::PrintViewManager(this));
-  print_preview_.reset(new printing::PrintPreviewMessageHandler(this));
-  fav_icon_helper_.reset(new FavIconHelper(this));
-  autofill_manager_.reset(new AutoFillManager(this));
-  autocomplete_history_manager_.reset(new AutocompleteHistoryManager(this));
-  prerender_plt_recorder_.reset(new prerender::PrerenderPLTRecorder(this));
-  desktop_notification_handler_.reset(
-      new DesktopNotificationHandlerForTC(this, GetRenderProcessHost()));
-  plugin_observer_.reset(new PluginObserver(this));
-  safebrowsing_detection_host_.reset(new safe_browsing::ClientSideDetectionHost(
-      this));
-}
-
-// static
-void TabContents::RegisterUserPrefs(PrefService* prefs) {
-  prefs->RegisterBooleanPref(prefs::kAlternateErrorPagesEnabled, true);
-
-  WebPreferences pref_defaults;
-  prefs->RegisterBooleanPref(prefs::kWebKitJavascriptEnabled,
-                             pref_defaults.javascript_enabled);
-  prefs->RegisterBooleanPref(prefs::kWebKitWebSecurityEnabled,
-                             pref_defaults.web_security_enabled);
-  prefs->RegisterBooleanPref(
-      prefs::kWebKitJavascriptCanOpenWindowsAutomatically, true);
-  prefs->RegisterBooleanPref(prefs::kWebKitLoadsImagesAutomatically,
-                             pref_defaults.loads_images_automatically);
-  prefs->RegisterBooleanPref(prefs::kWebKitPluginsEnabled,
-                             pref_defaults.plugins_enabled);
-  prefs->RegisterBooleanPref(prefs::kWebKitDomPasteEnabled,
-                             pref_defaults.dom_paste_enabled);
-  prefs->RegisterBooleanPref(prefs::kWebKitShrinksStandaloneImagesToFit,
-                             pref_defaults.shrinks_standalone_images_to_fit);
-  prefs->RegisterDictionaryPref(prefs::kWebKitInspectorSettings);
-  prefs->RegisterBooleanPref(prefs::kWebKitTextAreasAreResizable,
-                             pref_defaults.text_areas_are_resizable);
-  prefs->RegisterBooleanPref(prefs::kWebKitJavaEnabled,
-                             pref_defaults.java_enabled);
-  prefs->RegisterBooleanPref(prefs::kWebkitTabsToLinks,
-                             pref_defaults.tabs_to_links);
-
-  prefs->RegisterLocalizedStringPref(prefs::kAcceptLanguages,
-                                     IDS_ACCEPT_LANGUAGES);
-  prefs->RegisterLocalizedStringPref(prefs::kDefaultCharset,
-                                     IDS_DEFAULT_ENCODING);
-  prefs->RegisterLocalizedBooleanPref(prefs::kWebKitStandardFontIsSerif,
-                                      IDS_STANDARD_FONT_IS_SERIF);
-  prefs->RegisterLocalizedStringPref(prefs::kWebKitFixedFontFamily,
-                                     IDS_FIXED_FONT_FAMILY);
-  prefs->RegisterLocalizedStringPref(prefs::kWebKitSerifFontFamily,
-                                     IDS_SERIF_FONT_FAMILY);
-  prefs->RegisterLocalizedStringPref(prefs::kWebKitSansSerifFontFamily,
-                                     IDS_SANS_SERIF_FONT_FAMILY);
-  prefs->RegisterLocalizedStringPref(prefs::kWebKitCursiveFontFamily,
-                                     IDS_CURSIVE_FONT_FAMILY);
-  prefs->RegisterLocalizedStringPref(prefs::kWebKitFantasyFontFamily,
-                                     IDS_FANTASY_FONT_FAMILY);
-  prefs->RegisterLocalizedIntegerPref(prefs::kWebKitDefaultFontSize,
-                                      IDS_DEFAULT_FONT_SIZE);
-  prefs->RegisterLocalizedIntegerPref(prefs::kWebKitDefaultFixedFontSize,
-                                      IDS_DEFAULT_FIXED_FONT_SIZE);
-  prefs->RegisterLocalizedIntegerPref(prefs::kWebKitMinimumFontSize,
-                                      IDS_MINIMUM_FONT_SIZE);
-  prefs->RegisterLocalizedIntegerPref(prefs::kWebKitMinimumLogicalFontSize,
-                                      IDS_MINIMUM_LOGICAL_FONT_SIZE);
-  prefs->RegisterLocalizedBooleanPref(prefs::kWebKitUsesUniversalDetector,
-                                      IDS_USES_UNIVERSAL_DETECTOR);
-  prefs->RegisterLocalizedStringPref(prefs::kStaticEncodings,
-                                     IDS_STATIC_ENCODING_LIST);
-}
-
-bool TabContents::OnMessageReceived(const IPC::Message& message) {
-  ObserverListBase<TabContentsObserver>::Iterator it(observers_);
-  TabContentsObserver* observer;
-  while ((observer = it.GetNext()) != NULL)
-    if (observer->OnMessageReceived(message))
-      return true;
-
-  bool handled = true;
-  bool message_is_ok = true;
-  IPC_BEGIN_MESSAGE_MAP_EX(TabContents, message, message_is_ok)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_DidStartProvisionalLoadForFrame,
-                        OnDidStartProvisionalLoadForFrame)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_DidRedirectProvisionalLoad,
-                        OnDidRedirectProvisionalLoad)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_DidFailProvisionalLoadWithError,
-                        OnDidFailProvisionalLoadWithError)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_DidLoadResourceFromMemoryCache,
-                        OnDidLoadResourceFromMemoryCache)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_DidDisplayInsecureContent,
-                        OnDidDisplayInsecureContent)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_DidRunInsecureContent,
-                        OnDidRunInsecureContent)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_DocumentLoadedInFrame,
-                        OnDocumentLoadedInFrame)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_DidFinishLoad, OnDidFinishLoad)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_UpdateContentRestrictions,
-                        OnUpdateContentRestrictions)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_PDFHasUnsupportedFeature,
-                        OnPDFHasUnsupportedFeature)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_GoToEntryAtOffset, OnGoToEntryAtOffset)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_DidGetApplicationInfo,
-                        OnDidGetApplicationInfo)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_InstallApplication,
-                        OnInstallApplication)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_PageContents, OnPageContents)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_PageTranslated, OnPageTranslated)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_SetSuggestions, OnSetSuggestions)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_InstantSupportDetermined,
-                        OnInstantSupportDetermined)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_RunFileChooser, OnRunFileChooser)
-    IPC_MESSAGE_UNHANDLED(handled = false)
-  IPC_END_MESSAGE_MAP_EX()
-
-  if (!message_is_ok) {
-    UserMetrics::RecordAction(UserMetricsAction("BadMessageTerminate_RVD"));
-    GetRenderProcessHost()->ReceivedBadMessage();
-  }
-
-  return handled;
-}
-
-// Returns true if contains content rendered by an extension.
-bool TabContents::HostsExtension() const {
-  return GetURL().SchemeIs(chrome::kExtensionScheme);
-}
-
-TabContentsSSLHelper* TabContents::GetSSLHelper() {
-  if (ssl_helper_.get() == NULL)
-    ssl_helper_.reset(new TabContentsSSLHelper(this));
-  return ssl_helper_.get();
-}
-
-RenderProcessHost* TabContents::GetRenderProcessHost() const {
-  return render_manager_.current_host()->process();
-}
-
-void TabContents::SetExtensionApp(const Extension* extension) {
-  DCHECK(!extension || extension->GetFullLaunchURL().is_valid());
-  extension_app_ = extension;
-
-  UpdateExtensionAppIcon(extension_app_);
-
-  NotificationService::current()->Notify(
-      NotificationType::TAB_CONTENTS_APPLICATION_EXTENSION_CHANGED,
-      Source<TabContents>(this),
-      NotificationService::NoDetails());
-}
-
-void TabContents::SetExtensionAppById(const std::string& extension_app_id) {
-  if (extension_app_id.empty())
-    return;
-
-  ExtensionService* extension_service = profile()->GetExtensionService();
-  if (!extension_service || !extension_service->is_ready())
-    return;
-
-  const Extension* extension =
-      extension_service->GetExtensionById(extension_app_id, false);
-  if (extension)
-    SetExtensionApp(extension);
-}
-
-SkBitmap* TabContents::GetExtensionAppIcon() {
-  if (extension_app_icon_.empty())
-    return NULL;
-
-  return &extension_app_icon_;
-}
-
-const GURL& TabContents::GetURL() const {
-  // We may not have a navigation entry yet
-  NavigationEntry* entry = controller_.GetActiveEntry();
-  return entry ? entry->virtual_url() : GURL::EmptyGURL();
-}
-
-const string16& TabContents::GetTitle() const {
-  // Transient entries take precedence. They are used for interstitial pages
-  // that are shown on top of existing pages.
-  NavigationEntry* entry = controller_.GetTransientEntry();
-  if (entry) {
-    return entry->GetTitleForDisplay(profile()->GetPrefs()->
-        GetString(prefs::kAcceptLanguages));
-  }
-  WebUI* our_web_ui = render_manager_.pending_web_ui() ?
-      render_manager_.pending_web_ui() : render_manager_.web_ui();
-  if (our_web_ui) {
-    // Don't override the title in view source mode.
-    entry = controller_.GetActiveEntry();
-    if (!(entry && entry->IsViewSourceMode())) {
-      // Give the Web UI the chance to override our title.
-      const string16& title = our_web_ui->overridden_title();
-      if (!title.empty())
-        return title;
-    }
-  }
-
-  // We use the title for the last committed entry rather than a pending
-  // navigation entry. For example, when the user types in a URL, we want to
-  // keep the old page's title until the new load has committed and we get a new
-  // title.
-  entry = controller_.GetLastCommittedEntry();
-  if (entry) {
-    return entry->GetTitleForDisplay(profile()->GetPrefs()->
-        GetString(prefs::kAcceptLanguages));
-  }
-  return EmptyString16();
-}
-
-// static
-string16 TabContents::GetDefaultTitle() {
-  return l10n_util::GetStringUTF16(IDS_DEFAULT_TAB_TITLE);
-}
-
-int32 TabContents::GetMaxPageID() {
-  if (GetSiteInstance())
-    return GetSiteInstance()->max_page_id();
-  else
-    return max_page_id_;
-}
-
-void TabContents::UpdateMaxPageID(int32 page_id) {
-  // Ensure both the SiteInstance and RenderProcessHost update their max page
-  // IDs in sync. Only TabContents will also have site instances, except during
-  // testing.
-  if (GetSiteInstance())
-    GetSiteInstance()->UpdateMaxPageID(page_id);
-  GetRenderProcessHost()->UpdateMaxPageID(page_id);
-}
-
-SiteInstance* TabContents::GetSiteInstance() const {
-  return render_manager_.current_host()->site_instance();
-}
-
-bool TabContents::ShouldDisplayURL() {
-  // Don't hide the url in view source mode and with interstitials.
-  NavigationEntry* entry = controller_.GetActiveEntry();
-  if (entry && (entry->IsViewSourceMode() ||
-                entry->page_type() == INTERSTITIAL_PAGE)) {
-    return true;
-  }
-
-  // We always display the URL for non-WebUI URLs to prevent spoofing.
-  if (entry && !WebUIFactory::HasWebUIScheme(entry->url()))
-    return true;
-
-  WebUI* web_ui = GetWebUIForCurrentState();
-  if (web_ui)
-    return !web_ui->should_hide_url();
-  return true;
-}
-
-SkBitmap TabContents::GetFavIcon() const {
-  // Like GetTitle(), we also want to use the favicon for the last committed
-  // entry rather than a pending navigation entry.
-  NavigationEntry* entry = controller_.GetTransientEntry();
-  if (entry)
-    return entry->favicon().bitmap();
-
-  entry = controller_.GetLastCommittedEntry();
-  if (entry)
-    return entry->favicon().bitmap();
-  return SkBitmap();
-}
-
-bool TabContents::FavIconIsValid() const {
-  NavigationEntry* entry = controller_.GetTransientEntry();
-  if (entry)
-    return entry->favicon().is_valid();
-
-  entry = controller_.GetLastCommittedEntry();
-  if (entry)
-    return entry->favicon().is_valid();
-
-  return false;
-}
-
-bool TabContents::ShouldDisplayFavIcon() {
-  // Always display a throbber during pending loads.
-  if (controller_.GetLastCommittedEntry() && controller_.pending_entry())
-    return true;
-
-  WebUI* web_ui = GetWebUIForCurrentState();
-  if (web_ui)
-    return !web_ui->hide_favicon();
-  return true;
-}
-
-string16 TabContents::GetStatusText() const {
-  if (!is_loading() || load_state_ == net::LOAD_STATE_IDLE)
-    return string16();
-
-  switch (load_state_) {
-    case net::LOAD_STATE_WAITING_FOR_CACHE:
-      return l10n_util::GetStringUTF16(IDS_LOAD_STATE_WAITING_FOR_CACHE);
-    case net::LOAD_STATE_ESTABLISHING_PROXY_TUNNEL:
-      return
-          l10n_util::GetStringUTF16(IDS_LOAD_STATE_ESTABLISHING_PROXY_TUNNEL);
-    case net::LOAD_STATE_RESOLVING_PROXY_FOR_URL:
-      return l10n_util::GetStringUTF16(IDS_LOAD_STATE_RESOLVING_PROXY_FOR_URL);
-    case net::LOAD_STATE_RESOLVING_HOST:
-      return l10n_util::GetStringUTF16(IDS_LOAD_STATE_RESOLVING_HOST);
-    case net::LOAD_STATE_CONNECTING:
-      return l10n_util::GetStringUTF16(IDS_LOAD_STATE_CONNECTING);
-    case net::LOAD_STATE_SSL_HANDSHAKE:
-      return l10n_util::GetStringUTF16(IDS_LOAD_STATE_SSL_HANDSHAKE);
-    case net::LOAD_STATE_SENDING_REQUEST:
-      if (upload_size_)
-        return l10n_util::GetStringFUTF16Int(
-                    IDS_LOAD_STATE_SENDING_REQUEST_WITH_PROGRESS,
-                    static_cast<int>((100 * upload_position_) / upload_size_));
-      else
-        return l10n_util::GetStringUTF16(IDS_LOAD_STATE_SENDING_REQUEST);
-    case net::LOAD_STATE_WAITING_FOR_RESPONSE:
-      return l10n_util::GetStringFUTF16(IDS_LOAD_STATE_WAITING_FOR_RESPONSE,
-                                        load_state_host_);
-    // Ignore net::LOAD_STATE_READING_RESPONSE and net::LOAD_STATE_IDLE
-    case net::LOAD_STATE_IDLE:
-    case net::LOAD_STATE_READING_RESPONSE:
-      break;
-  }
-
-  return string16();
-}
-
-void TabContents::AddObserver(TabContentsObserver* observer) {
-  observers_.AddObserver(observer);
-}
-
-void TabContents::RemoveObserver(TabContentsObserver* observer) {
-  observers_.RemoveObserver(observer);
-}
-
-void TabContents::SetIsCrashed(base::TerminationStatus status, int error_code) {
-  if (status == crashed_status_)
-    return;
-
-  crashed_status_ = status;
-  crashed_error_code_ = error_code;
-  NotifyNavigationStateChanged(INVALIDATE_TAB);
-}
-
-void TabContents::PageActionStateChanged() {
-  NotifyNavigationStateChanged(TabContents::INVALIDATE_PAGE_ACTIONS);
-}
-
-void TabContents::NotifyNavigationStateChanged(unsigned changed_flags) {
-  if (delegate_)
-    delegate_->NavigationStateChanged(this, changed_flags);
-}
-
-void TabContents::DidBecomeSelected() {
-  controller_.SetActive(true);
-  RenderWidgetHostView* rwhv = GetRenderWidgetHostView();
-  if (rwhv) {
-    rwhv->DidBecomeSelected();
-#if defined(OS_MACOSX)
-    rwhv->SetActive(true);
-#endif
-  }
-
-  WebCacheManager::GetInstance()->ObserveActivity(GetRenderProcessHost()->id());
-  last_selected_time_ = base::TimeTicks::Now();
-#if defined(OS_CHROMEOS)
-  chromeos::LocaleChangeGuard::Check(this);
-#endif
-}
-
-void TabContents::FadeForInstant(bool animate) {
-  RenderWidgetHostView* rwhv = GetRenderWidgetHostView();
-  SkColor whitish = SkColorSetARGB(192, 255, 255, 255);
-  if (rwhv)
-    rwhv->SetVisuallyDeemphasized(&whitish, animate);
-}
-
-void TabContents::CancelInstantFade() {
-  RenderWidgetHostView* rwhv = GetRenderWidgetHostView();
-  if (rwhv)
-    rwhv->SetVisuallyDeemphasized(NULL, false);
-}
-
-void TabContents::WasHidden() {
-  if (!capturing_contents()) {
-    // |render_view_host()| can be NULL if the user middle clicks a link to open
-    // a tab in then background, then closes the tab before selecting it.  This
-    // is because closing the tab calls TabContents::Destroy(), which removes
-    // the |render_view_host()|; then when we actually destroy the window,
-    // OnWindowPosChanged() notices and calls HideContents() (which calls us).
-    RenderWidgetHostView* rwhv = GetRenderWidgetHostView();
-    if (rwhv)
-      rwhv->WasHidden();
-  }
-
-  NotificationService::current()->Notify(
-      NotificationType::TAB_CONTENTS_HIDDEN,
-      Source<TabContents>(this),
-      NotificationService::NoDetails());
-}
-
-void TabContents::Activate() {
-  if (delegate_)
-    delegate_->ActivateContents(this);
-}
-
-void TabContents::Deactivate() {
-  if (delegate_)
-    delegate_->DeactivateContents(this);
-}
-
-void TabContents::ShowContents() {
-  RenderWidgetHostView* rwhv = GetRenderWidgetHostView();
-  if (rwhv)
-    rwhv->DidBecomeSelected();
-}
-
-void TabContents::HideContents() {
-  // TODO(pkasting): http://b/1239839  Right now we purposefully don't call
-  // our superclass HideContents(), because some callers want to be very picky
-  // about the order in which these get called.  In addition to making the code
-  // here practically impossible to understand, this also means we end up
-  // calling TabContents::WasHidden() twice if callers call both versions of
-  // HideContents() on a TabContents.
-  WasHidden();
-}
-
-bool TabContents::NeedToFireBeforeUnload() {
-  // TODO(creis): Should we fire even for interstitial pages?
-  return notify_disconnection() &&
-      !showing_interstitial_page() &&
-      !render_view_host()->SuddenTerminationAllowed();
-}
-
-void TabContents::OpenURL(const GURL& url, const GURL& referrer,
-                          WindowOpenDisposition disposition,
-                          PageTransition::Type transition) {
-  if (delegate_)
-    delegate_->OpenURLFromTab(this, url, referrer, disposition, transition);
-}
-
-bool TabContents::NavigateToPendingEntry(
-    NavigationController::ReloadType reload_type) {
-  return NavigateToEntry(*controller_.pending_entry(), reload_type);
-}
-
-bool TabContents::NavigateToEntry(
-    const NavigationEntry& entry,
-    NavigationController::ReloadType reload_type) {
-  RenderViewHost* dest_render_view_host = render_manager_.Navigate(entry);
-  if (!dest_render_view_host)
-    return false;  // Unable to create the desired render view host.
-
-  if (delegate_ && delegate_->ShouldEnablePreferredSizeNotifications()) {
-    dest_render_view_host->EnablePreferredSizeChangedMode(
-        kPreferredSizeWidth | kPreferredSizeHeightThisIsSlow);
-  }
-
-  // For security, we should never send non-Web-UI URLs to a Web UI renderer.
-  // Double check that here.
-  int enabled_bindings = dest_render_view_host->enabled_bindings();
-  bool is_allowed_in_web_ui_renderer =
-      WebUIFactory::IsURLAcceptableForWebUI(profile(), entry.url());
-  CHECK(!BindingsPolicy::is_web_ui_enabled(enabled_bindings) ||
-        is_allowed_in_web_ui_renderer);
-
-  // Tell DevTools agent that it is attached prior to the navigation.
-  DevToolsManager* devtools_manager = DevToolsManager::GetInstance();
-  if (devtools_manager) {  // NULL in unit tests.
-    devtools_manager->OnNavigatingToPendingEntry(render_view_host(),
-                                                 dest_render_view_host,
-                                                 entry.url());
-  }
-
-  // Used for page load time metrics.
-  current_load_start_ = base::TimeTicks::Now();
-
-  // Navigate in the desired RenderViewHost.
-  ViewMsg_Navigate_Params navigate_params;
-  MakeNavigateParams(entry, controller_, reload_type, &navigate_params);
-  if (delegate_) {
-    navigate_params.extra_headers =
-        delegate_->GetNavigationHeaders(navigate_params.url);
-  }
-  dest_render_view_host->Navigate(navigate_params);
-
-  if (entry.page_id() == -1) {
-    // HACK!!  This code suppresses javascript: URLs from being added to
-    // session history, which is what we want to do for javascript: URLs that
-    // do not generate content.  What we really need is a message from the
-    // renderer telling us that a new page was not created.  The same message
-    // could be used for mailto: URLs and the like.
-    if (entry.url().SchemeIs(chrome::kJavaScriptScheme))
-      return false;
-  }
-
-  // Notify observers about navigation.
-  FOR_EACH_OBSERVER(TabContentsObserver, observers_, NavigateToPendingEntry());
-
-  if (reload_type != NavigationController::NO_RELOAD &&
-      !profile()->IsOffTheRecord()) {
-    FaviconService* favicon_service =
-        profile()->GetFaviconService(Profile::IMPLICIT_ACCESS);
-    if (favicon_service)
-      favicon_service->SetFaviconOutOfDateForPage(entry.url());
-  }
-
-  return true;
-}
-
-void TabContents::Stop() {
-  render_manager_.Stop();
-  printing_->Stop();
-}
-
-void TabContents::DisassociateFromPopupCount() {
-  render_view_host()->DisassociateFromPopupCount();
-}
-
-TabContents* TabContents::Clone() {
-  // We create a new SiteInstance so that the new tab won't share processes
-  // with the old one. This can be changed in the future if we need it to share
-  // processes for some reason.
-  TabContents* tc = new TabContents(profile(),
-                                    SiteInstance::CreateSiteInstance(profile()),
-                                    MSG_ROUTING_NONE, this, NULL);
-  tc->controller().CopyStateFrom(controller_);
-  tc->extension_app_ = extension_app_;
-  tc->extension_app_icon_ = extension_app_icon_;
-  return tc;
-}
-
-void TabContents::ShowPageInfo(const GURL& url,
-                               const NavigationEntry::SSLStatus& ssl,
-                               bool show_history) {
-  if (!delegate_)
-    return;
-
-  delegate_->ShowPageInfo(profile(), url, ssl, show_history);
-}
-
-void TabContents::SaveFavicon() {
-  NavigationEntry* entry = controller_.GetActiveEntry();
-  if (!entry || entry->url().is_empty())
-    return;
-
-  // Make sure the page is in history, otherwise adding the favicon does
-  // nothing.
-  HistoryService* history = profile()->GetOriginalProfile()->GetHistoryService(
-      Profile::IMPLICIT_ACCESS);
-  if (!history)
-    return;
-  history->AddPageNoVisitForBookmark(entry->url());
-
-  FaviconService* service = profile()->GetOriginalProfile()->GetFaviconService(
-      Profile::IMPLICIT_ACCESS);
-  if (!service)
-    return;
-  const NavigationEntry::FaviconStatus& favicon(entry->favicon());
-  if (!favicon.is_valid() || favicon.url().is_empty() ||
-      favicon.bitmap().empty()) {
-    return;
-  }
-  std::vector<unsigned char> image_data;
-  gfx::PNGCodec::EncodeBGRASkBitmap(favicon.bitmap(), false, &image_data);
-  service->SetFavicon(entry->url(), favicon.url(), image_data);
-}
-
-ConstrainedWindow* TabContents::CreateConstrainedDialog(
-      ConstrainedWindowDelegate* delegate) {
-  ConstrainedWindow* window =
-      ConstrainedWindow::CreateConstrainedDialog(this, delegate);
-  child_windows_.push_back(window);
-
-  if (child_windows_.size() == 1) {
-    window->ShowConstrainedWindow();
-    BlockTabContent(true);
-  }
-
-  return window;
-}
-
-void TabContents::BlockTabContent(bool blocked) {
-  RenderWidgetHostView* rwhv = GetRenderWidgetHostView();
-  // 70% opaque grey.
-  SkColor greyish = SkColorSetARGB(178, 0, 0, 0);
-  if (rwhv)
-    rwhv->SetVisuallyDeemphasized(blocked ? &greyish : NULL, false);
-  render_view_host()->set_ignore_input_events(blocked);
-  if (delegate_)
-    delegate_->SetTabContentBlocked(this, blocked);
-}
-
-void TabContents::AddNewContents(TabContents* new_contents,
-                                 WindowOpenDisposition disposition,
-                                 const gfx::Rect& initial_pos,
-                                 bool user_gesture) {
-  if (all_contents_blocked_) {
-    if (!blocked_contents_)
-      blocked_contents_ = new BlockedContentContainer(this);
-    blocked_contents_->AddTabContents(
-        new_contents, disposition, initial_pos, user_gesture);
-    return;
-  }
-
-  if (!delegate_)
-    return;
-
-  if ((disposition == NEW_POPUP) && !user_gesture &&
-      !CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kDisablePopupBlocking)) {
-    // Unrequested popups from normal pages are constrained unless they're in
-    // the whitelist.  The popup owner will handle checking this.
-    delegate_->GetConstrainingContents(this)->AddPopup(
-        new_contents, initial_pos);
-  } else {
-    new_contents->DisassociateFromPopupCount();
-    delegate_->AddNewContents(this, new_contents, disposition, initial_pos,
-                              user_gesture);
-    NotificationService::current()->Notify(
-        NotificationType::TAB_ADDED,
-        Source<TabContentsDelegate>(delegate_),
-        Details<TabContents>(this));
-  }
-
-  // TODO(pkasting): Why is this necessary?
-  PopupNotificationVisibilityChanged(blocked_contents_ != NULL);
-}
-
-bool TabContents::ExecuteCode(int request_id, const std::string& extension_id,
-                              bool is_js_code, const std::string& code_string,
-                              bool all_frames) {
-  RenderViewHost* host = render_view_host();
-  if (!host)
-    return false;
-
-  return host->Send(new ViewMsg_ExecuteCode(host->routing_id(),
-      ViewMsg_ExecuteCode_Params(request_id, extension_id,
-                                 is_js_code, code_string, all_frames)));
-}
-
-void TabContents::PopupNotificationVisibilityChanged(bool visible) {
-  if (is_being_destroyed_)
-    return;
-  content_settings_delegate_->SetPopupsBlocked(visible);
-  if (!dont_notify_render_view_)
-    render_view_host()->AllowScriptToClose(!visible);
-}
-
-gfx::NativeView TabContents::GetContentNativeView() const {
-  return view_->GetContentNativeView();
-}
-
-gfx::NativeView TabContents::GetNativeView() const {
-  return view_->GetNativeView();
-}
-
-void TabContents::GetContainerBounds(gfx::Rect *out) const {
-  view_->GetContainerBounds(out);
-}
-
-void TabContents::Focus() {
-  view_->Focus();
-}
-
-void TabContents::FocusThroughTabTraversal(bool reverse) {
-  if (showing_interstitial_page()) {
-    render_manager_.interstitial_page()->FocusThroughTabTraversal(reverse);
-    return;
-  }
-  render_view_host()->SetInitialFocus(reverse);
-}
-
-bool TabContents::FocusLocationBarByDefault() {
-  WebUI* web_ui = GetWebUIForCurrentState();
-  if (web_ui)
-    return web_ui->focus_location_bar_by_default();
-  NavigationEntry* entry = controller_.GetActiveEntry();
-  if (entry && entry->url() == GURL(chrome::kAboutBlankURL))
-    return true;
-  return false;
-}
-
-void TabContents::SetFocusToLocationBar(bool select_all) {
-  if (delegate())
-    delegate()->SetFocusToLocationBar(select_all);
-}
-
-void TabContents::AddInfoBar(InfoBarDelegate* delegate) {
-  if (delegate_ && !delegate_->infobars_enabled()) {
-    delegate->InfoBarClosed();
-    return;
-  }
-
-  // Look through the existing InfoBarDelegates we have for a match. If we've
-  // already got one that matches, then we don't add the new one.
-  for (size_t i = 0; i < infobar_count(); ++i) {
-    if (GetInfoBarDelegateAt(i)->EqualsDelegate(delegate)) {
-      // Tell the new infobar to close so that it can clean itself up.
-      delegate->InfoBarClosed();
-      return;
-    }
-  }
-
-  infobar_delegates_.push_back(delegate);
-  NotificationService::current()->Notify(
-      NotificationType::TAB_CONTENTS_INFOBAR_ADDED, Source<TabContents>(this),
-      Details<InfoBarDelegate>(delegate));
-
-  // Add ourselves as an observer for navigations the first time a delegate is
-  // added. We use this notification to expire InfoBars that need to expire on
-  // page transitions.
-  if (infobar_delegates_.size() == 1) {
-    registrar_.Add(this, NotificationType::NAV_ENTRY_COMMITTED,
-                   Source<NavigationController>(&controller_));
-  }
-}
-
-void TabContents::RemoveInfoBar(InfoBarDelegate* delegate) {
-  if (delegate_ && !delegate_->infobars_enabled()) {
-    return;
-  }
-
-  std::vector<InfoBarDelegate*>::iterator it =
-      find(infobar_delegates_.begin(), infobar_delegates_.end(), delegate);
-  if (it != infobar_delegates_.end()) {
-    InfoBarDelegate* delegate = *it;
-    NotificationService::current()->Notify(
-        NotificationType::TAB_CONTENTS_INFOBAR_REMOVED,
-        Source<TabContents>(this),
-        Details<InfoBarDelegate>(delegate));
-
-    infobar_delegates_.erase(it);
-    // Remove ourselves as an observer if we are tracking no more InfoBars.
-    if (infobar_delegates_.empty()) {
-      registrar_.Remove(this, NotificationType::NAV_ENTRY_COMMITTED,
-                        Source<NavigationController>(&controller_));
-    }
-  }
-}
-
-void TabContents::ReplaceInfoBar(InfoBarDelegate* old_delegate,
-                                 InfoBarDelegate* new_delegate) {
-  if (delegate_ && !delegate_->infobars_enabled()) {
-    new_delegate->InfoBarClosed();
-    return;
-  }
-
-  std::vector<InfoBarDelegate*>::iterator it =
-      find(infobar_delegates_.begin(), infobar_delegates_.end(), old_delegate);
-  DCHECK(it != infobar_delegates_.end());
-
-  // Notify the container about the change of plans.
-  scoped_ptr<std::pair<InfoBarDelegate*, InfoBarDelegate*> > details(
-    new std::pair<InfoBarDelegate*, InfoBarDelegate*>(
-        old_delegate, new_delegate));
-  NotificationService::current()->Notify(
-      NotificationType::TAB_CONTENTS_INFOBAR_REPLACED,
-      Source<TabContents>(this),
-      Details<std::pair<InfoBarDelegate*, InfoBarDelegate*> >(details.get()));
-
-  // Remove the old one.
-  infobar_delegates_.erase(it);
-
-  // Add the new one.
-  DCHECK(find(infobar_delegates_.begin(),
-              infobar_delegates_.end(), new_delegate) ==
-         infobar_delegates_.end());
-  infobar_delegates_.push_back(new_delegate);
-}
-
-bool TabContents::ShouldShowBookmarkBar() {
-  if (showing_interstitial_page())
-    return false;
-
-  // Do not show bookmarks bar if bookmarks aren't enabled.
-  if (!browser_defaults::bookmarks_enabled)
-    return false;
-
-  // See GetWebUIForCurrentState() comment for more info. This case is very
-  // similar, but for non-first loads, we want to use the committed entry. This
-  // is so the bookmarks bar disappears at the same time the page does.
-  if (controller_.GetLastCommittedEntry()) {
-    // Not the first load, always use the committed Web UI.
-    return (render_manager_.web_ui() == NULL) ?
-        false : render_manager_.web_ui()->force_bookmark_bar_visible();
-  }
-
-  // When it's the first load, we know either the pending one or the committed
-  // one will have the Web UI in it (see GetWebUIForCurrentState), and only one
-  // of them will be valid, so we can just check both.
-  if (render_manager_.pending_web_ui())
-    return render_manager_.pending_web_ui()->force_bookmark_bar_visible();
-  return (render_manager_.web_ui() == NULL) ?
-      false : render_manager_.web_ui()->force_bookmark_bar_visible();
-}
-
-void TabContents::ToolbarSizeChanged(bool is_animating) {
-  TabContentsDelegate* d = delegate();
-  if (d)
-    d->ToolbarSizeChanged(this, is_animating);
-}
-
-bool TabContents::CanDownload(int request_id) {
-  TabContentsDelegate* d = delegate();
-  if (d)
-    return d->CanDownload(request_id);
-  return true;
-}
-
-void TabContents::OnStartDownload(DownloadItem* download) {
-  DCHECK(download);
-
-  // Download in a constrained popup is shown in the tab that opened it.
-  TabContents* tab_contents = delegate()->GetConstrainingContents(this);
-
-  if (tab_contents && tab_contents->delegate())
-    tab_contents->delegate()->OnStartDownload(download, this);
-}
-
-void TabContents::WillClose(ConstrainedWindow* window) {
-  ConstrainedWindowList::iterator i(
-      std::find(child_windows_.begin(), child_windows_.end(), window));
-  bool removed_topmost_window = i == child_windows_.begin();
-  if (i != child_windows_.end())
-    child_windows_.erase(i);
-  if (child_windows_.empty()) {
-    BlockTabContent(false);
-  } else {
-    if (removed_topmost_window)
-      child_windows_[0]->ShowConstrainedWindow();
-    BlockTabContent(true);
-  }
-}
-
-void TabContents::WillCloseBlockedContentContainer(
-    BlockedContentContainer* container) {
-  DCHECK(blocked_contents_ == container);
-  blocked_contents_ = NULL;
-  PopupNotificationVisibilityChanged(false);
-}
-
-void TabContents::DidMoveOrResize(ConstrainedWindow* window) {
-#if defined(OS_WIN)
-  UpdateWindow(GetNativeView());
-#endif
-}
-
-void TabContents::OnSavePage() {
-  // If we can not save the page, try to download it.
-  if (!SavePackage::IsSavableContents(contents_mime_type())) {
-    DownloadManager* dlm = profile()->GetDownloadManager();
-    const GURL& current_page_url = GetURL();
-    if (dlm && current_page_url.is_valid())
-      dlm->DownloadUrl(current_page_url, GURL(), "", this);
-    return;
-  }
-
-  Stop();
-
-  // Create the save package and possibly prompt the user for the name to save
-  // the page as. The user prompt is an asynchronous operation that runs on
-  // another thread.
-  save_package_ = new SavePackage(this);
-  save_package_->GetSaveInfo();
-}
-
-// Used in automated testing to bypass prompting the user for file names.
-// Instead, the names and paths are hard coded rather than running them through
-// file name sanitation and extension / mime checking.
-bool TabContents::SavePage(const FilePath& main_file, const FilePath& dir_path,
-                           SavePackage::SavePackageType save_type) {
-  // Stop the page from navigating.
-  Stop();
-
-  save_package_ = new SavePackage(this, save_type, main_file, dir_path);
-  return save_package_->Init();
-}
-
-void TabContents::EmailPageLocation() {
-  std::string title = EscapeQueryParamValue(UTF16ToUTF8(GetTitle()), false);
-  std::string page_url = EscapeQueryParamValue(GetURL().spec(), false);
-  std::string mailto = std::string("mailto:?subject=Fwd:%20") +
-      title + "&body=%0A%0A" + page_url;
-  platform_util::OpenExternal(GURL(mailto));
-}
-
-void TabContents::PrintPreview() {
-  if (CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kEnablePrintPreview)) {
-    if (showing_interstitial_page())
-      return;
-
-    printing::PrintPreviewTabController* tab_controller =
-      printing::PrintPreviewTabController::GetInstance();
-    if (!tab_controller)
-      return;
-    tab_controller->GetOrCreatePreviewTab(this, controller().window_id().id());
-
-    render_view_host()->PrintPreview();
-  } else {
-    PrintNow();
-  }
-}
-
-bool TabContents::PrintNow() {
-  // We can't print interstitial page for now.
-  if (showing_interstitial_page())
-    return false;
-
-  return render_view_host()->PrintPages();
-}
-
-void TabContents::PrintingDone(int document_cookie, bool success) {
-  render_view_host()->PrintingDone(document_cookie, success);
-}
-
-bool TabContents::IsActiveEntry(int32 page_id) {
-  NavigationEntry* active_entry = controller_.GetActiveEntry();
-  return (active_entry != NULL &&
-          active_entry->site_instance() == GetSiteInstance() &&
-          active_entry->page_id() == page_id);
-}
-
-void TabContents::SetOverrideEncoding(const std::string& encoding) {
-  set_encoding(encoding);
-  render_view_host()->SetPageEncoding(encoding);
-}
-
-void TabContents::ResetOverrideEncoding() {
-  reset_encoding();
-  render_view_host()->ResetPageEncodingToDefault();
-}
-
-void TabContents::WindowMoveOrResizeStarted() {
-  render_view_host()->WindowMoveOrResizeStarted();
-}
-
-void TabContents::SetAllContentsBlocked(bool value) {
-  if (all_contents_blocked_ == value)
-    return;
-
-  all_contents_blocked_ = value;
-  if (!all_contents_blocked_ && blocked_contents_) {
-    std::vector<TabContents*> blocked;
-    blocked_contents_->GetBlockedContents(&blocked);
-    for (size_t i = 0; i < blocked.size(); ++i)
-      blocked_contents_->LaunchForContents(blocked[i]);
-  }
-}
-
-void TabContents::LogNewTabTime(const std::string& event_name) {
-  // Not all new tab pages get timed.  In those cases, we don't have a
-  // new_tab_start_time_.
-  if (new_tab_start_time_.is_null())
-    return;
-
-  base::TimeDelta duration = base::TimeTicks::Now() - new_tab_start_time_;
-  MetricEventDurationDetails details(event_name,
-      static_cast<int>(duration.InMilliseconds()));
-
-  if (event_name == "Tab.NewTabScriptStart") {
-    UMA_HISTOGRAM_TIMES("Tab.NewTabScriptStart", duration);
-  } else if (event_name == "Tab.NewTabDOMContentLoaded") {
-    UMA_HISTOGRAM_TIMES("Tab.NewTabDOMContentLoaded", duration);
-  } else if (event_name == "Tab.NewTabOnload") {
-    UMA_HISTOGRAM_TIMES("Tab.NewTabOnload", duration);
-    // The new tab page has finished loading; reset it.
-    new_tab_start_time_ = base::TimeTicks();
-  } else {
-    NOTREACHED();
-  }
-  NotificationService::current()->Notify(
-      NotificationType::METRIC_EVENT_DURATION,
-      Source<TabContents>(this),
-      Details<MetricEventDurationDetails>(&details));
-}
-
-void TabContents::OnCloseStarted() {
-  if (tab_close_start_time_.is_null())
-    tab_close_start_time_ = base::TimeTicks::Now();
-}
-
-bool TabContents::ShouldAcceptDragAndDrop() const {
-#if defined(OS_CHROMEOS)
-  // ChromeOS panels (pop-ups) do not take drag-n-drop.
-  // See http://crosbug.com/2413
-  if (delegate() && delegate()->IsPopup(this))
-    return false;
-  return true;
-#else
-  return true;
-#endif
-}
-
-void TabContents::SystemDragEnded() {
-  if (render_view_host())
-    render_view_host()->DragSourceSystemDragEnded();
-  if (delegate())
-    delegate()->DragEnded();
-}
-
-void TabContents::UpdateHistoryForNavigation(
-    scoped_refptr<history::HistoryAddPageArgs> add_page_args) {
-  if (profile()->IsOffTheRecord())
-    return;
-
-  // Add to history service.
-  HistoryService* hs = profile()->GetHistoryService(Profile::IMPLICIT_ACCESS);
-  if (hs)
-    hs->AddPage(*add_page_args);
-}
-
-void TabContents::UpdateHistoryPageTitle(const NavigationEntry& entry) {
-  if (profile()->IsOffTheRecord())
-    return;
-
-  HistoryService* hs = profile()->GetHistoryService(Profile::IMPLICIT_ACCESS);
-  if (hs)
-    hs->SetPageTitle(entry.virtual_url(), entry.title());
-}
-
-double TabContents::GetZoomLevel() const {
-  HostZoomMap* zoom_map = profile()->GetHostZoomMap();
-  if (!zoom_map)
-    return 0;
-
-  double zoom_level;
-  if (temporary_zoom_settings_) {
-    zoom_level = zoom_map->GetTemporaryZoomLevel(
-        GetRenderProcessHost()->id(), render_view_host()->routing_id());
-  } else {
-    zoom_level = zoom_map->GetZoomLevel(GetURL());
-  }
-  return zoom_level;
-}
-
-int TabContents::GetZoomPercent(bool* enable_increment,
-                                bool* enable_decrement) {
-  *enable_decrement = *enable_increment = false;
-  int percent = static_cast<int>(
-      WebKit::WebView::zoomLevelToZoomFactor(GetZoomLevel()) * 100);
-  *enable_decrement = percent > minimum_zoom_percent_;
-  *enable_increment = percent < maximum_zoom_percent_;
-  return percent;
-}
-
-void TabContents::ViewSource() {
-  if (!delegate_)
-    return;
-
-  NavigationEntry* active_entry = controller().GetActiveEntry();
-  if (!active_entry)
-    return;
-
-  delegate_->ViewSourceForTab(this, active_entry->url());
-}
-
-void TabContents::OnDidStartProvisionalLoadForFrame(int64 frame_id,
-                                                    bool is_main_frame,
-                                                    const GURL& url) {
-  bool is_error_page = (url.spec() == chrome::kUnreachableWebDataURL);
-  GURL validated_url(url);
-  render_view_host()->FilterURL(ChildProcessSecurityPolicy::GetInstance(),
-      GetRenderProcessHost()->id(), &validated_url);
-
-  ProvisionalLoadDetails details(
-      is_main_frame,
-      controller_.IsURLInPageNavigation(validated_url),
-      validated_url, std::string(), false, is_error_page, frame_id);
-  NotificationService::current()->Notify(
-      NotificationType::FRAME_PROVISIONAL_LOAD_START,
-      Source<NavigationController>(&controller_),
-      Details<ProvisionalLoadDetails>(&details));
-  if (is_main_frame) {
-    // If we're displaying a network error page do not reset the content
-    // settings delegate's cookies so the user has a chance to modify cookie
-    // settings.
-    if (!is_error_page)
-      content_settings_delegate_->ClearCookieSpecificContentSettings();
-    content_settings_delegate_->ClearGeolocationContentSettings();
-
-    // Check if the URL we are about to load has been prerendered by any chance,
-    // and use it if possible.
-    MaybeUsePreloadedPage(url);
-  }
-}
-
-void TabContents::OnDidRedirectProvisionalLoad(int32 page_id,
-                                               const GURL& source_url,
-                                               const GURL& target_url) {
-  NavigationEntry* entry;
-  if (page_id == -1)
-    entry = controller_.pending_entry();
-  else
-    entry = controller_.GetEntryWithPageID(GetSiteInstance(), page_id);
-  if (!entry || entry->url() != source_url)
-    return;
-  entry->set_url(target_url);
-
-  // Check if the URL we are about to load has been prerendered by any chance,
-  // and use it if possible.
-  MaybeUsePreloadedPage(target_url);
-}
-
-void TabContents::OnDidFailProvisionalLoadWithError(
-    int64 frame_id,
-    bool is_main_frame,
-    int error_code,
-    const GURL& url,
-    bool showing_repost_interstitial) {
-  VLOG(1) << "Failed Provisional Load: " << url.possibly_invalid_spec()
-          << ", error_code: " << error_code
-          << " is_main_frame: " << is_main_frame
-          << " showing_repost_interstitial: " << showing_repost_interstitial
-          << " frame_id: " << frame_id;
-  GURL validated_url(url);
-  render_view_host()->FilterURL(ChildProcessSecurityPolicy::GetInstance(),
-      GetRenderProcessHost()->id(), &validated_url);
-
-  if (net::ERR_ABORTED == error_code) {
-    // EVIL HACK ALERT! Ignore failed loads when we're showing interstitials.
-    // This means that the interstitial won't be torn down properly, which is
-    // bad. But if we have an interstitial, go back to another tab type, and
-    // then load the same interstitial again, we could end up getting the first
-    // interstitial's "failed" message (as a result of the cancel) when we're on
-    // the second one.
-    //
-    // We can't tell this apart, so we think we're tearing down the current page
-    // which will cause a crash later one. There is also some code in
-    // RenderViewHostManager::RendererAbortedProvisionalLoad that is commented
-    // out because of this problem.
-    //
-    // http://code.google.com/p/chromium/issues/detail?id=2855
-    // Because this will not tear down the interstitial properly, if "back" is
-    // back to another tab type, the interstitial will still be somewhat alive
-    // in the previous tab type. If you navigate somewhere that activates the
-    // tab with the interstitial again, you'll see a flash before the new load
-    // commits of the interstitial page.
-    if (showing_interstitial_page()) {
-      LOG(WARNING) << "Discarding message during interstitial.";
-      return;
-    }
-
-    // This will discard our pending entry if we cancelled the load (e.g., if we
-    // decided to download the file instead of load it). Only discard the
-    // pending entry if the URLs match, otherwise the user initiated a navigate
-    // before the page loaded so that the discard would discard the wrong entry.
-    NavigationEntry* pending_entry = controller_.pending_entry();
-    if (pending_entry && pending_entry->url() == validated_url) {
-      controller_.DiscardNonCommittedEntries();
-      // Update the URL display.
-      NotifyNavigationStateChanged(TabContents::INVALIDATE_URL);
-    }
-
-    render_manager_.RendererAbortedProvisionalLoad(render_view_host());
-  }
-
-  // Send out a notification that we failed a provisional load with an error.
-  ProvisionalLoadDetails details(
-      is_main_frame, controller_.IsURLInPageNavigation(validated_url),
-      validated_url, std::string(), false, false, frame_id);
-  details.set_error_code(error_code);
-
-  NotificationService::current()->Notify(
-      NotificationType::FAIL_PROVISIONAL_LOAD_WITH_ERROR,
-      Source<NavigationController>(&controller_),
-      Details<ProvisionalLoadDetails>(&details));
-}
-
-void TabContents::OnDidLoadResourceFromMemoryCache(
-    const GURL& url,
-    const std::string& security_info) {
-  static base::StatsCounter cache("WebKit.CacheHit");
-  cache.Increment();
-
-  // Send out a notification that we loaded a resource from our memory cache.
-  int cert_id = 0, cert_status = 0, security_bits = -1, connection_status = 0;
-  SSLManager::DeserializeSecurityInfo(security_info,
-                                      &cert_id, &cert_status,
-                                      &security_bits,
-                                      &connection_status);
-  LoadFromMemoryCacheDetails details(url, GetRenderProcessHost()->id(),
-                                     cert_id, cert_status);
-
-  NotificationService::current()->Notify(
-      NotificationType::LOAD_FROM_MEMORY_CACHE,
-      Source<NavigationController>(&controller_),
-      Details<LoadFromMemoryCacheDetails>(&details));
-}
-
-void TabContents::OnDidDisplayInsecureContent() {
-  displayed_insecure_content_ = true;
-  SSLManager::NotifySSLInternalStateChanged();
-}
-
-void TabContents::OnDidRunInsecureContent(
-    const std::string& security_origin, const GURL& target_url) {
-  LOG(INFO) << security_origin << " ran insecure content from "
-            << target_url.possibly_invalid_spec();
-  controller_.ssl_manager()->DidRunInsecureContent(security_origin);
-}
-
-void TabContents::OnDocumentLoadedInFrame(int64 frame_id) {
-  controller_.DocumentLoadedInFrame();
-  NotificationService::current()->Notify(
-      NotificationType::FRAME_DOM_CONTENT_LOADED,
-      Source<NavigationController>(&controller_),
-      Details<int64>(&frame_id));
-}
-
-void TabContents::OnDidFinishLoad(int64 frame_id) {
-  NotificationService::current()->Notify(
-      NotificationType::FRAME_DID_FINISH_LOAD,
-      Source<NavigationController>(&controller_),
-      Details<int64>(&frame_id));
-}
-
-void TabContents::OnUpdateContentRestrictions(int restrictions) {
-  content_restrictions_ = restrictions;
-  delegate()->ContentRestrictionsChanged(this);
-}
-
-void TabContents::OnPDFHasUnsupportedFeature() {
-  PDFHasUnsupportedFeature(this);
-}
-
-// Notifies the RenderWidgetHost instance about the fact that the page is
-// loading, or done loading and calls the base implementation.
-void TabContents::SetIsLoading(bool is_loading,
-                               LoadNotificationDetails* details) {
-  if (is_loading == is_loading_)
-    return;
-
-  if (!is_loading) {
-    load_state_ = net::LOAD_STATE_IDLE;
-    load_state_host_.clear();
-    upload_size_ = 0;
-    upload_position_ = 0;
-  }
-
-  render_manager_.SetIsLoading(is_loading);
-
-  is_loading_ = is_loading;
-  waiting_for_response_ = is_loading;
-
-  if (delegate_)
-    delegate_->LoadingStateChanged(this);
-  NotifyNavigationStateChanged(INVALIDATE_LOAD);
-
-  NotificationType type = is_loading ? NotificationType::LOAD_START :
-      NotificationType::LOAD_STOP;
-  NotificationDetails det = NotificationService::NoDetails();
-  if (details)
-      det = Details<LoadNotificationDetails>(details);
-  NotificationService::current()->Notify(type,
-      Source<NavigationController>(&controller_),
-      det);
-}
-
-void TabContents::AddPopup(TabContents* new_contents,
-                           const gfx::Rect& initial_pos) {
-  // A page can't spawn popups (or do anything else, either) until its load
-  // commits, so when we reach here, the popup was spawned by the
-  // NavigationController's last committed entry, not the active entry.  For
-  // example, if a page opens a popup in an onunload() handler, then the active
-  // entry is the page to be loaded as we navigate away from the unloading
-  // page.  For this reason, we can't use GetURL() to get the opener URL,
-  // because it returns the active entry.
-  NavigationEntry* entry = controller_.GetLastCommittedEntry();
-  GURL creator = entry ? entry->virtual_url() : GURL::EmptyGURL();
-
-  if (creator.is_valid() &&
-      profile()->GetHostContentSettingsMap()->GetContentSetting(
-          creator, CONTENT_SETTINGS_TYPE_POPUPS, "") == CONTENT_SETTING_ALLOW) {
-    AddNewContents(new_contents, NEW_POPUP, initial_pos, true);
-  } else {
-    if (!blocked_contents_)
-      blocked_contents_ = new BlockedContentContainer(this);
-    blocked_contents_->AddTabContents(new_contents, NEW_POPUP, initial_pos,
-                                      true);
-    content_settings_delegate_->OnContentBlocked(CONTENT_SETTINGS_TYPE_POPUPS,
-                                                 std::string());
-  }
-}
-
-void TabContents::ExpireInfoBars(
-    const NavigationController::LoadCommittedDetails& details) {
-  // Only hide InfoBars when the user has done something that makes the main
-  // frame load. We don't want various automatic or subframe navigations making
-  // it disappear.
-  if (!details.is_user_initiated_main_frame_load())
-    return;
-
-  // NOTE: It is not safe to change the following code to count upwards or use
-  // iterators, as the RemoveInfoBar() call synchronously modifies our delegate
-  // list.
-  for (size_t i = infobar_count(); i > 0; --i) {
-    InfoBarDelegate* delegate = GetInfoBarDelegateAt(i - 1);
-    if (delegate->ShouldExpire(details))
-      RemoveInfoBar(delegate);
-  }
-}
-
-WebUI* TabContents::GetWebUIForCurrentState() {
-  // When there is a pending navigation entry, we want to use the pending WebUI
-  // that goes along with it to control the basic flags. For example, we want to
-  // show the pending URL in the URL bar, so we want the display_url flag to
-  // be from the pending entry.
-  //
-  // The confusion comes because there are multiple possibilities for the
-  // initial load in a tab as a side effect of the way the RenderViewHostManager
-  // works.
-  //
-  //  - For the very first tab the load looks "normal". The new tab Web UI is
-  //    the pending one, and we want it to apply here.
-  //
-  //  - For subsequent new tabs, they'll get a new SiteInstance which will then
-  //    get switched to the one previously associated with the new tab pages.
-  //    This switching will cause the manager to commit the RVH/WebUI. So we'll
-  //    have a committed Web UI in this case.
-  //
-  // This condition handles all of these cases:
-  //
-  //  - First load in first tab: no committed nav entry + pending nav entry +
-  //    pending dom ui:
-  //    -> Use pending Web UI if any.
-  //
-  //  - First load in second tab: no committed nav entry + pending nav entry +
-  //    no pending Web UI:
-  //    -> Use the committed Web UI if any.
-  //
-  //  - Second navigation in any tab: committed nav entry + pending nav entry:
-  //    -> Use pending Web UI if any.
-  //
-  //  - Normal state with no load: committed nav entry + no pending nav entry:
-  //    -> Use committed Web UI.
-  if (controller_.pending_entry() &&
-      (controller_.GetLastCommittedEntry() ||
-       render_manager_.pending_web_ui()))
-    return render_manager_.pending_web_ui();
-  return render_manager_.web_ui();
-}
-
-void TabContents::DidNavigateMainFramePostCommit(
-    const NavigationController::LoadCommittedDetails& details,
-    const ViewHostMsg_FrameNavigate_Params& params) {
-  if (opener_web_ui_type_ != WebUIFactory::kNoWebUI) {
-    // If this is a window.open navigation, use the same WebUI as the renderer
-    // that opened the window, as long as both renderers have the same
-    // privileges.
-    if (opener_web_ui_type_ ==
-        WebUIFactory::GetWebUIType(profile(), GetURL())) {
-      WebUI* web_ui = WebUIFactory::CreateWebUIForURL(this, GetURL());
-      // web_ui might be NULL if the URL refers to a non-existent extension.
-      if (web_ui) {
-        render_manager_.SetWebUIPostCommit(web_ui);
-        web_ui->RenderViewCreated(render_view_host());
-      }
-    }
-    opener_web_ui_type_ = WebUIFactory::kNoWebUI;
-  }
-
-  if (details.is_user_initiated_main_frame_load()) {
-    // Clear the status bubble. This is a workaround for a bug where WebKit
-    // doesn't let us know that the cursor left an element during a
-    // transition (this is also why the mouse cursor remains as a hand after
-    // clicking on a link); see bugs 1184641 and 980803. We don't want to
-    // clear the bubble when a user navigates to a named anchor in the same
-    // page.
-    UpdateTargetURL(details.entry->page_id(), GURL());
-  }
-
-  // Allow the new page to set the title again.
-  received_page_title_ = false;
-
-  // Get the favicon, either from history or request it from the net.
-  fav_icon_helper_->FetchFavIcon(details.entry->url());
-
-  // Clear all page actions, blocked content notifications and browser actions
-  // for this tab, unless this is an in-page navigation.
-  if (!details.is_in_page) {
-    ExtensionService* service = profile()->GetExtensionService();
-    if (service) {
-      for (size_t i = 0; i < service->extensions()->size(); ++i) {
-        ExtensionAction* browser_action =
-            service->extensions()->at(i)->browser_action();
-        if (browser_action) {
-          browser_action->ClearAllValuesForTab(controller().session_id().id());
-          NotificationService::current()->Notify(
-              NotificationType::EXTENSION_BROWSER_ACTION_UPDATED,
-              Source<ExtensionAction>(browser_action),
-              NotificationService::NoDetails());
-        }
-
-        ExtensionAction* page_action =
-            service->extensions()->at(i)->page_action();
-        if (page_action) {
-          page_action->ClearAllValuesForTab(controller().session_id().id());
-          PageActionStateChanged();
-        }
-      }
-    }
-
-    // Close blocked popups.
-    if (blocked_contents_) {
-      AutoReset<bool> auto_reset(&dont_notify_render_view_, true);
-      blocked_contents_->Destroy();
-      blocked_contents_ = NULL;
-    }
-
-    // Clear "blocked" flags.
-    content_settings_delegate_->ClearBlockedContentSettingsExceptForCookies();
-    content_settings_delegate_->GeolocationDidNavigate(details);
-
-    // Once the main frame is navigated, we're no longer considered to have
-    // displayed insecure content.
-    displayed_insecure_content_ = false;
-  }
-
-  // Close constrained windows if necessary.
-  if (!net::RegistryControlledDomainService::SameDomainOrHost(
-      details.previous_url, details.entry->url()))
-    CloseConstrainedWindows();
-
-  // Notify observers about navigation.
-  FOR_EACH_OBSERVER(TabContentsObserver, observers_,
-                    DidNavigateMainFramePostCommit(details, params));
-}
-
-void TabContents::DidNavigateAnyFramePostCommit(
-    RenderViewHost* render_view_host,
-    const NavigationController::LoadCommittedDetails& details,
-    const ViewHostMsg_FrameNavigate_Params& params) {
-  // If we navigate, start showing messages again. This does nothing to prevent
-  // a malicious script from spamming messages, since the script could just
-  // reload the page to stop blocking.
-  suppress_javascript_messages_ = false;
-
-  // Notify observers about navigation.
-  FOR_EACH_OBSERVER(TabContentsObserver, observers_,
-                    DidNavigateAnyFramePostCommit(details, params));
-
-  // Let the LanguageState clear its state.
-  language_state_.DidNavigate(details);
-}
-
-void TabContents::CloseConstrainedWindows() {
-  // Clear out any constrained windows since we are leaving this page entirely.
-  // We use indices instead of iterators in case CloseWindow does something
-  // that may invalidate an iterator.
-  for (size_t i = 0; i < child_windows_.size(); ++i) {
-    ConstrainedWindow* window = child_windows_[child_windows_.size() - 1 - i];
-    if (window) {
-      window->CloseConstrainedWindow();
-      BlockTabContent(false);
-    }
-  }
-}
-
-void TabContents::UpdateAlternateErrorPageURL() {
-  GURL url = GetAlternateErrorPageURL();
-  render_view_host()->SetAlternateErrorPageURL(url);
-}
-
-void TabContents::UpdateWebPreferences() {
-  render_view_host()->UpdateWebPreferences(GetWebkitPrefs());
-}
-
-void TabContents::UpdateZoomLevel() {
-  render_view_host()->SetZoomLevel(GetZoomLevel());
-}
-
-void TabContents::UpdateMaxPageIDIfNecessary(SiteInstance* site_instance,
-                                             RenderViewHost* rvh) {
-  // If we are creating a RVH for a restored controller, then we might
-  // have more page IDs than the SiteInstance's current max page ID.  We must
-  // make sure that the max page ID is larger than any restored page ID.
-  // Note that it is ok for conflicting page IDs to exist in another tab
-  // (i.e., NavigationController), but if any page ID is larger than the max,
-  // the back/forward list will get confused.
-  int max_restored_page_id = controller_.max_restored_page_id();
-  if (max_restored_page_id > 0) {
-    int curr_max_page_id = site_instance->max_page_id();
-    if (max_restored_page_id > curr_max_page_id) {
-      // Need to update the site instance immediately.
-      site_instance->UpdateMaxPageID(max_restored_page_id);
-
-      // Also tell the renderer to update its internal representation.  We
-      // need to reserve enough IDs to make all restored page IDs less than
-      // the max.
-      if (curr_max_page_id < 0)
-        curr_max_page_id = 0;
-      rvh->ReservePageIDRange(max_restored_page_id - curr_max_page_id);
-    }
-  }
-}
-
-scoped_refptr<history::HistoryAddPageArgs>
-TabContents::CreateHistoryAddPageArgs(
-    const GURL& virtual_url,
-    const NavigationController::LoadCommittedDetails& details,
-    const ViewHostMsg_FrameNavigate_Params& params) {
-  scoped_refptr<history::HistoryAddPageArgs> add_page_args(
-      new history::HistoryAddPageArgs(
-          params.url, base::Time::Now(), this, params.page_id, params.referrer,
-          params.redirects, params.transition, history::SOURCE_BROWSED,
-          details.did_replace_entry));
-  if (PageTransition::IsMainFrame(params.transition) &&
-      virtual_url != params.url) {
-    // Hack on the "virtual" URL so that it will appear in history. For some
-    // types of URLs, we will display a magic URL that is different from where
-    // the page is actually navigated. We want the user to see in history what
-    // they saw in the URL bar, so we add the virtual URL as a redirect.  This
-    // only applies to the main frame, as the virtual URL doesn't apply to
-    // sub-frames.
-    add_page_args->url = virtual_url;
-    if (!add_page_args->redirects.empty())
-      add_page_args->redirects.back() = virtual_url;
-  }
-  return add_page_args;
-}
-
-bool TabContents::UpdateTitleForEntry(NavigationEntry* entry,
-                                      const std::wstring& title) {
-  // For file URLs without a title, use the pathname instead. In the case of a
-  // synthesized title, we don't want the update to count toward the "one set
-  // per page of the title to history."
-  string16 final_title;
-  bool explicit_set;
-  if (entry->url().SchemeIsFile() && title.empty()) {
-    final_title = UTF8ToUTF16(entry->url().ExtractFileName());
-    explicit_set = false;  // Don't count synthetic titles toward the set limit.
-  } else {
-    TrimWhitespace(WideToUTF16Hack(title), TRIM_ALL, &final_title);
-    explicit_set = true;
-  }
-
-  if (final_title == entry->title())
-    return false;  // Nothing changed, don't bother.
-
-  entry->set_title(final_title);
-
-  if (!received_page_title_) {
-    UpdateHistoryPageTitle(*entry);
-    received_page_title_ = explicit_set;
-  }
-
-  // Lastly, set the title for the view.
-  view_->SetPageTitle(UTF16ToWideHack(final_title));
-
-  NotificationService::current()->Notify(
-      NotificationType::TAB_CONTENTS_TITLE_UPDATED,
-      Source<TabContents>(this),
-      NotificationService::NoDetails());
-
-  return true;
-}
-
-void TabContents::NotifySwapped() {
-  // After sending out a swap notification, we need to send a disconnect
-  // notification so that clients that pick up a pointer to |this| can NULL the
-  // pointer.  See Bug 1230284.
-  notify_disconnection_ = true;
-  NotificationService::current()->Notify(
-      NotificationType::TAB_CONTENTS_SWAPPED,
-      Source<TabContents>(this),
-      NotificationService::NoDetails());
-}
-
-void TabContents::NotifyConnected() {
-  notify_disconnection_ = true;
-  NotificationService::current()->Notify(
-      NotificationType::TAB_CONTENTS_CONNECTED,
-      Source<TabContents>(this),
-      NotificationService::NoDetails());
-}
-
-void TabContents::NotifyDisconnected() {
-  if (!notify_disconnection_)
-    return;
-
-  notify_disconnection_ = false;
-  NotificationService::current()->Notify(
-      NotificationType::TAB_CONTENTS_DISCONNECTED,
-      Source<TabContents>(this),
-      NotificationService::NoDetails());
-}
-
-void TabContents::OnGoToEntryAtOffset(int offset) {
-  if (!delegate_ || delegate_->OnGoToEntryOffset(offset)) {
-    NavigationEntry* entry = controller_.GetEntryAtOffset(offset);
-    if (!entry)
-      return;
-    // Note that we don't call NavigationController::GotToOffset() as we don't
-    // want to create a pending navigation entry (it might end up lingering
-    // http://crbug.com/51680).
-    entry->set_transition_type(entry->transition_type() |
-                               PageTransition::FORWARD_BACK);
-    NavigateToEntry(*entry, NavigationController::NO_RELOAD);
-  }
-}
-
-void TabContents::OnDidGetApplicationInfo(int32 page_id,
-                                          const WebApplicationInfo& info) {
-  web_app_info_ = info;
-
-  if (delegate())
-    delegate()->OnDidGetApplicationInfo(this, page_id);
-}
-
-void TabContents::OnInstallApplication(const WebApplicationInfo& info) {
-  if (delegate())
-    delegate()->OnInstallApplication(this, info);
-}
-
-void TabContents::OnPageContents(const GURL& url,
-                                 int32 page_id,
-                                 const string16& contents,
-                                 const std::string& language,
-                                 bool page_translatable) {
-  // Don't index any https pages. People generally don't want their bank
-  // accounts, etc. indexed on their computer, especially since some of these
-  // things are not marked cachable.
-  // TODO(brettw) we may want to consider more elaborate heuristics such as
-  // the cachability of the page. We may also want to consider subframes (this
-  // test will still index subframes if the subframe is SSL).
-  // TODO(zelidrag) bug chromium-os:2808 - figure out if we want to reenable
-  // content indexing for chromeos in some future releases.
-#if !defined(OS_CHROMEOS)
-  if (!url.SchemeIsSecure()) {
-    Profile* p = profile();
-    if (p && !p->IsOffTheRecord()) {
-      HistoryService* hs = p->GetHistoryService(Profile::IMPLICIT_ACCESS);
-      if (hs)
-        hs->SetPageContents(url, contents);
-    }
-  }
-#endif
-
-  language_state_.LanguageDetermined(language, page_translatable);
-
-  std::string lang = language;
-  NotificationService::current()->Notify(
-      NotificationType::TAB_LANGUAGE_DETERMINED,
-      Source<TabContents>(this),
-      Details<std::string>(&lang));
-
-  // Generate the thumbnail here if the in-browser thumbnailing is enabled.
-  if (CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kEnableInBrowserThumbnailing)) {
-    ThumbnailGenerator::UpdateThumbnailIfNecessary(this, url);
-  }
-}
-
-void TabContents::OnPageTranslated(int32 page_id,
-                                   const std::string& original_lang,
-                                   const std::string& translated_lang,
-                                   TranslateErrors::Type error_type) {
-  language_state_.set_current_language(translated_lang);
-  language_state_.set_translation_pending(false);
-  PageTranslatedDetails details(original_lang, translated_lang, error_type);
-  NotificationService::current()->Notify(
-      NotificationType::PAGE_TRANSLATED,
-      Source<TabContents>(this),
-      Details<PageTranslatedDetails>(&details));
-}
-
-void TabContents::OnSetSuggestions(
-    int32 page_id,
-    const std::vector<std::string>& suggestions) {
-  if (delegate())
-    delegate()->OnSetSuggestions(page_id, suggestions);
-}
-
-void TabContents::OnInstantSupportDetermined(int32 page_id, bool result) {
-  if (delegate())
-    delegate()->OnInstantSupportDetermined(page_id, result);
-}
-
-void TabContents::OnRunFileChooser(
-    const ViewHostMsg_RunFileChooser_Params& params) {
-  if (file_select_helper_.get() == NULL)
-    file_select_helper_.reset(new FileSelectHelper(profile()));
-  file_select_helper_->RunFileChooser(render_view_host(), params);
-}
-
-
-void TabContents::OnContentSettingsAccessed(bool content_was_blocked) {
-  if (delegate_)
-    delegate_->OnContentSettingsChange(this);
-}
-
-RenderViewHostDelegate::View* TabContents::GetViewDelegate() {
-  return view_.get();
-}
-
-RenderViewHostDelegate::RendererManagement*
-TabContents::GetRendererManagementDelegate() {
-  return &render_manager_;
-}
-
-RenderViewHostDelegate::ContentSettings*
-TabContents::GetContentSettingsDelegate() {
-  return content_settings_delegate_.get();
-}
-
-RenderViewHostDelegate::SSL* TabContents::GetSSLDelegate() {
-  return GetSSLHelper();
-}
-
-AutomationResourceRoutingDelegate*
-TabContents::GetAutomationResourceRoutingDelegate() {
-  return delegate();
-}
-
-RenderViewHostDelegate::BookmarkDrag* TabContents::GetBookmarkDragDelegate() {
-  return bookmark_drag_;
-}
-
-void TabContents::SetBookmarkDragDelegate(
-    RenderViewHostDelegate::BookmarkDrag* bookmark_drag) {
-  bookmark_drag_ = bookmark_drag;
-}
-
-TabSpecificContentSettings* TabContents::GetTabSpecificContentSettings() const {
-  return content_settings_delegate_.get();
-}
-
-RendererPreferences TabContents::GetRendererPrefs(Profile* profile) const {
-  return renderer_preferences_;
-}
-
-TabContents* TabContents::GetAsTabContents() {
-  return this;
-}
-
-ViewType::Type TabContents::GetRenderViewType() const {
-  return ViewType::TAB_CONTENTS;
-}
-
-int TabContents::GetBrowserWindowID() const {
-  return controller().window_id().id();
-}
-
-void TabContents::RenderViewCreated(RenderViewHost* render_view_host) {
-  NotificationService::current()->Notify(
-      NotificationType::RENDER_VIEW_HOST_CREATED_FOR_TAB,
-      Source<TabContents>(this),
-      Details<RenderViewHost>(render_view_host));
-  NavigationEntry* entry = controller_.GetActiveEntry();
-  if (!entry)
-    return;
-
-  // When we're creating views, we're still doing initial setup, so we always
-  // use the pending Web UI rather than any possibly existing committed one.
-  if (render_manager_.pending_web_ui()) {
-    render_manager_.pending_web_ui()->RenderViewCreated(render_view_host);
-  }
-
-  if (entry->IsViewSourceMode()) {
-    // Put the renderer in view source mode.
-    render_view_host->Send(
-        new ViewMsg_EnableViewSourceMode(render_view_host->routing_id()));
-  }
-
-  view()->RenderViewCreated(render_view_host);
-}
-
-void TabContents::RenderViewReady(RenderViewHost* rvh) {
-  if (rvh != render_view_host()) {
-    // Don't notify the world, since this came from a renderer in the
-    // background.
-    return;
-  }
-
-  NotifyConnected();
-  bool was_crashed = is_crashed();
-  SetIsCrashed(base::TERMINATION_STATUS_STILL_RUNNING, 0);
-
-  // Restore the focus to the tab (otherwise the focus will be on the top
-  // window).
-  if (was_crashed && !FocusLocationBarByDefault() &&
-      (!delegate_ || delegate_->ShouldFocusPageAfterCrash())) {
-    Focus();
-  }
-}
-
-void TabContents::RenderViewGone(RenderViewHost* rvh,
-                                 base::TerminationStatus status,
-                                 int error_code) {
-  // Ask the print preview if this renderer was valuable.
-  if (!printing_->OnRenderViewGone(rvh))
-    return;
-  if (rvh != render_view_host()) {
-    // The pending page's RenderViewHost is gone.
-    return;
-  }
-
-  SetIsLoading(false, NULL);
-  NotifyDisconnected();
-  SetIsCrashed(status, error_code);
-
-  // Remove all infobars.
-  while (!infobar_delegates_.empty())
-    RemoveInfoBar(GetInfoBarDelegateAt(infobar_count() - 1));
-
-  // Tell the view that we've crashed so it can prepare the sad tab page.
-  // Only do this if we're not in browser shutdown, so that TabContents
-  // objects that are not in a browser (e.g., HTML dialogs) and thus are
-  // visible do not flash a sad tab page.
-  if (browser_shutdown::GetShutdownType() == browser_shutdown::NOT_VALID)
-    view_->OnTabCrashed(status, error_code);
-
-  // Hide any visible hung renderer warning for this web contents' process.
-  hung_renderer_dialog::HideForTabContents(this);
-}
-
-void TabContents::RenderViewDeleted(RenderViewHost* rvh) {
-  NotificationService::current()->Notify(
-      NotificationType::RENDER_VIEW_HOST_DELETED,
-      Source<TabContents>(this),
-      Details<RenderViewHost>(rvh));
-  render_manager_.RenderViewDeleted(rvh);
-}
-
-void TabContents::DidNavigate(RenderViewHost* rvh,
-                              const ViewHostMsg_FrameNavigate_Params& params) {
-  int extra_invalidate_flags = 0;
-
-  if (PageTransition::IsMainFrame(params.transition)) {
-    if (MaybeUsePreloadedPage(params.url)) {
-      return;
-    }
-
-    bool was_bookmark_bar_visible = ShouldShowBookmarkBar();
-
-    render_manager_.DidNavigateMainFrame(rvh);
-
-    if (was_bookmark_bar_visible != ShouldShowBookmarkBar())
-      extra_invalidate_flags |= INVALIDATE_BOOKMARK_BAR;
-  }
-
-  // Update the site of the SiteInstance if it doesn't have one yet.
-  if (!GetSiteInstance()->has_site())
-    GetSiteInstance()->SetSite(params.url);
-
-  // Need to update MIME type here because it's referred to in
-  // UpdateNavigationCommands() called by RendererDidNavigate() to
-  // determine whether or not to enable the encoding menu.
-  // It's updated only for the main frame. For a subframe,
-  // RenderView::UpdateURL does not set params.contents_mime_type.
-  // (see http://code.google.com/p/chromium/issues/detail?id=2929 )
-  // TODO(jungshik): Add a test for the encoding menu to avoid
-  // regressing it again.
-  if (PageTransition::IsMainFrame(params.transition))
-    contents_mime_type_ = params.contents_mime_type;
-
-  NavigationController::LoadCommittedDetails details;
-  bool did_navigate = controller_.RendererDidNavigate(
-      params, extra_invalidate_flags, &details);
-
-  // Send notification about committed provisional loads. This notification is
-  // different from the NAV_ENTRY_COMMITTED notification which doesn't include
-  // the actual URL navigated to and isn't sent for AUTO_SUBFRAME navigations.
-  if (details.type != NavigationType::NAV_IGNORE) {
-    // For AUTO_SUBFRAME navigations, an event for the main frame is generated
-    // that is not recorded in the navigation history. For the purpose of
-    // tracking navigation events, we treat this event as a sub frame navigation
-    // event.
-    bool is_main_frame = did_navigate ? details.is_main_frame : false;
-    ProvisionalLoadDetails load_details(
-        is_main_frame, details.is_in_page, params.url, std::string(), false,
-        false, params.frame_id);
-    load_details.set_transition_type(params.transition);
-    // Whether or not a page transition was triggered by going backward or
-    // forward in the history is only stored in the navigation controller's
-    // entry list.
-    if (did_navigate &&
-        (controller_.GetActiveEntry()->transition_type() &
-            PageTransition::FORWARD_BACK)) {
-      load_details.set_transition_type(
-          params.transition | PageTransition::FORWARD_BACK);
-    }
-    NotificationService::current()->Notify(
-        NotificationType::FRAME_PROVISIONAL_LOAD_COMMITTED,
-        Source<NavigationController>(&controller_),
-        Details<ProvisionalLoadDetails>(&load_details));
-  }
-
-  // Update history. Note that this needs to happen after the entry is complete,
-  // which WillNavigate[Main,Sub]Frame will do before this function is called.
-  if (params.should_update_history) {
-    // Most of the time, the displayURL matches the loaded URL, but for about:
-    // URLs, we use a data: URL as the real value.  We actually want to save the
-    // about: URL to the history db and keep the data: URL hidden. This is what
-    // the TabContents' URL getter does.
-    scoped_refptr<history::HistoryAddPageArgs> add_page_args(
-        CreateHistoryAddPageArgs(GetURL(), details, params));
-    if (!delegate() ||
-        delegate()->ShouldAddNavigationToHistory(*add_page_args,
-                                                 details.type)) {
-      UpdateHistoryForNavigation(add_page_args);
-    }
-  }
-
-  if (!did_navigate)
-    return;  // No navigation happened.
-
-  // DO NOT ADD MORE STUFF TO THIS FUNCTION! Your component should either listen
-  // for the appropriate notification (best) or you can add it to
-  // DidNavigateMainFramePostCommit / DidNavigateAnyFramePostCommit (only if
-  // necessary, please).
-
-  // Run post-commit tasks.
-  if (details.is_main_frame)
-    DidNavigateMainFramePostCommit(details, params);
-  DidNavigateAnyFramePostCommit(rvh, details, params);
-}
-
-void TabContents::UpdateState(RenderViewHost* rvh,
-                              int32 page_id,
-                              const std::string& state) {
-  DCHECK(rvh == render_view_host());
-
-  // We must be prepared to handle state updates for any page, these occur
-  // when the user is scrolling and entering form data, as well as when we're
-  // leaving a page, in which case our state may have already been moved to
-  // the next page. The navigation controller will look up the appropriate
-  // NavigationEntry and update it when it is notified via the delegate.
-
-  int entry_index = controller_.GetEntryIndexWithPageID(
-      GetSiteInstance(), page_id);
-  if (entry_index < 0)
-    return;
-  NavigationEntry* entry = controller_.GetEntryAtIndex(entry_index);
-
-  if (state == entry->content_state())
-    return;  // Nothing to update.
-  entry->set_content_state(state);
-  controller_.NotifyEntryChanged(entry, entry_index);
-}
-
-void TabContents::UpdateTitle(RenderViewHost* rvh,
-                              int32 page_id, const std::wstring& title) {
-  // If we have a title, that's a pretty good indication that we've started
-  // getting useful data.
-  SetNotWaitingForResponse();
-
-  DCHECK(rvh == render_view_host());
-  NavigationEntry* entry = controller_.GetEntryWithPageID(rvh->site_instance(),
-                                                          page_id);
-  if (!entry || !UpdateTitleForEntry(entry, title))
-    return;
-
-  // Broadcast notifications when the UI should be updated.
-  if (entry == controller_.GetEntryAtOffset(0))
-    NotifyNavigationStateChanged(INVALIDATE_TITLE);
-}
-
-void TabContents::UpdateEncoding(RenderViewHost* render_view_host,
-                                 const std::string& encoding) {
-  set_encoding(encoding);
-}
-
-void TabContents::UpdateTargetURL(int32 page_id, const GURL& url) {
-  if (delegate())
-    delegate()->UpdateTargetURL(this, url);
-}
-
-void TabContents::UpdateThumbnail(const GURL& url,
-                                  const SkBitmap& bitmap,
-                                  const ThumbnailScore& score) {
-  if (profile()->IsOffTheRecord())
-    return;
-
-  // Tell History about this thumbnail
-  history::TopSites* ts = profile()->GetTopSites();
-  if (ts)
-    ts->SetPageThumbnail(url, bitmap, score);
-}
-
-void TabContents::UpdateInspectorSetting(const std::string& key,
-                                         const std::string& value) {
-  RenderViewHostDelegateHelper::UpdateInspectorSetting(profile(), key, value);
-}
-
-void TabContents::ClearInspectorSettings() {
-  RenderViewHostDelegateHelper::ClearInspectorSettings(profile());
-}
-
-void TabContents::Close(RenderViewHost* rvh) {
-  // The UI may be in an event-tracking loop, such as between the
-  // mouse-down and mouse-up in text selection or a button click.
-  // Defer the close until after tracking is complete, so that we
-  // don't free objects out from under the UI.
-  // TODO(shess): This could probably be integrated with the
-  // IsDoingDrag() test below.  Punting for now because I need more
-  // research to understand how this impacts platforms other than Mac.
-  // TODO(shess): This could get more fine-grained.  For instance,
-  // closing a tab in another window while selecting text in the
-  // current window's Omnibox should be just fine.
-  if (view()->IsEventTracking()) {
-    view()->CloseTabAfterEventTracking();
-    return;
-  }
-
-  // If we close the tab while we're in the middle of a drag, we'll crash.
-  // Instead, cancel the drag and close it as soon as the drag ends.
-  if (view()->IsDoingDrag()) {
-    view()->CancelDragAndCloseTab();
-    return;
-  }
-
-  // Ignore this if it comes from a RenderViewHost that we aren't showing.
-  if (delegate() && rvh == render_view_host())
-    delegate()->CloseContents(this);
-}
-
-void TabContents::RequestMove(const gfx::Rect& new_bounds) {
-  if (delegate() && delegate()->IsPopup(this))
-    delegate()->MoveContents(this, new_bounds);
-}
-
-void TabContents::DidStartLoading() {
-  SetIsLoading(true, NULL);
-
-  if (delegate()) {
-    bool is_print_preview_tab =
-        printing::PrintPreviewTabController::IsPrintPreviewTab(this);
-    if (content_restrictions_ || is_print_preview_tab) {
-      content_restrictions_= is_print_preview_tab ?
-          CONTENT_RESTRICTION_PRINT : 0;
-      delegate()->ContentRestrictionsChanged(this);
-    }
-  }
-
-  // Notify observers about navigation.
-  FOR_EACH_OBSERVER(TabContentsObserver, observers_, DidStartLoading());
-}
-
-void TabContents::DidStopLoading() {
-  scoped_ptr<LoadNotificationDetails> details;
-
-  NavigationEntry* entry = controller_.GetActiveEntry();
-  // An entry may not exist for a stop when loading an initial blank page or
-  // if an iframe injected by script into a blank page finishes loading.
-  if (entry) {
-    base::TimeDelta elapsed = base::TimeTicks::Now() - current_load_start_;
-
-    details.reset(new LoadNotificationDetails(
-        entry->virtual_url(),
-        entry->transition_type(),
-        elapsed,
-        &controller_,
-        controller_.GetCurrentEntryIndex()));
-  }
-
-  SetIsLoading(false, details.get());
-
-  // Notify observers about navigation.
-  FOR_EACH_OBSERVER(TabContentsObserver, observers_, DidStopLoading());
-}
-
-void TabContents::DidChangeLoadProgress(double progress) {
-  if (delegate())
-    delegate()->LoadProgressChanged(progress);
-}
-
-void TabContents::DocumentOnLoadCompletedInMainFrame(
-    RenderViewHost* render_view_host,
-    int32 page_id) {
-  NotificationService::current()->Notify(
-      NotificationType::LOAD_COMPLETED_MAIN_FRAME,
-      Source<TabContents>(this),
-      Details<int>(&page_id));
-}
-
-void TabContents::RequestOpenURL(const GURL& url, const GURL& referrer,
-                                 WindowOpenDisposition disposition) {
-  if (render_manager_.web_ui()) {
-    // When we're a Web UI, it will provide a page transition type for us (this
-    // is so the new tab page can specify AUTO_BOOKMARK for automatically
-    // generated suggestions).
-    //
-    // Note also that we hide the referrer for Web UI pages. We don't really
-    // want web sites to see a referrer of "chrome://blah" (and some
-    // chrome: URLs might have search terms or other stuff we don't want to
-    // send to the site), so we send no referrer.
-    OpenURL(url, GURL(), disposition,
-            render_manager_.web_ui()->link_transition_type());
-  } else {
-    OpenURL(url, referrer, disposition, PageTransition::LINK);
-  }
-}
-
-void TabContents::DomOperationResponse(const std::string& json_string,
-                                       int automation_id) {
-}
-
-void TabContents::ProcessWebUIMessage(
-    const ViewHostMsg_DomMessage_Params& params) {
-  if (!render_manager_.web_ui()) {
-    // This can happen if someone uses window.open() to open an extension URL
-    // from a non-extension context.
-    render_view_host()->BlockExtensionRequest(params.request_id);
-    return;
-  }
-  render_manager_.web_ui()->ProcessWebUIMessage(params);
-}
-
-void TabContents::ProcessExternalHostMessage(const std::string& message,
-                                             const std::string& origin,
-                                             const std::string& target) {
-  if (delegate())
-    delegate()->ForwardMessageToExternalHost(message, origin, target);
-}
-
-void TabContents::RunJavaScriptMessage(
-    const std::wstring& message,
-    const std::wstring& default_prompt,
-    const GURL& frame_url,
-    const int flags,
-    IPC::Message* reply_msg,
-    bool* did_suppress_message) {
-  // Suppress javascript messages when requested and when inside a constrained
-  // popup window (because that activates them and breaks them out of the
-  // constrained window jail).
-  // Also suppress messages when showing an interstitial. The interstitial is
-  // shown over the previous page, we don't want the hidden page dialogs to
-  // interfere with the interstitial.
-  bool suppress_this_message =
-      suppress_javascript_messages_ ||
-      showing_interstitial_page() ||
-      (delegate() && delegate()->ShouldSuppressDialogs());
-  if (delegate())
-    suppress_this_message |=
-        (delegate()->GetConstrainingContents(this) != this);
-
-  *did_suppress_message = suppress_this_message;
-
-  if (!suppress_this_message) {
-    base::TimeDelta time_since_last_message(
-        base::TimeTicks::Now() - last_javascript_message_dismissal_);
-    bool show_suppress_checkbox = false;
-    // Show a checkbox offering to suppress further messages if this message is
-    // being displayed within kJavascriptMessageExpectedDelay of the last one.
-    if (time_since_last_message <
-        base::TimeDelta::FromMilliseconds(kJavascriptMessageExpectedDelay))
-      show_suppress_checkbox = true;
-
-    RunJavascriptMessageBox(profile(), this, frame_url, flags, message,
-                            default_prompt, show_suppress_checkbox, reply_msg);
-  } else {
-    // If we are suppressing messages, just reply as is if the user immediately
-    // pressed "Cancel".
-    OnMessageBoxClosed(reply_msg, false, std::wstring());
-  }
-}
-
-void TabContents::RunBeforeUnloadConfirm(const std::wstring& message,
-                                         IPC::Message* reply_msg) {
-  if (delegate())
-    delegate()->WillRunBeforeUnloadConfirm();
-  if (delegate() && delegate()->ShouldSuppressDialogs()) {
-    render_view_host()->JavaScriptMessageBoxClosed(reply_msg, true,
-                                                   std::wstring());
-    return;
-  }
-  is_showing_before_unload_dialog_ = true;
-  RunBeforeUnloadDialog(this, message, reply_msg);
-}
-
-void TabContents::ShowModalHTMLDialog(const GURL& url, int width, int height,
-                                      const std::string& json_arguments,
-                                      IPC::Message* reply_msg) {
-  if (delegate()) {
-    HtmlDialogUIDelegate* dialog_delegate =
-        new ModalHtmlDialogDelegate(url, width, height, json_arguments,
-                                    reply_msg, this);
-    delegate()->ShowHtmlDialog(dialog_delegate, NULL);
-  }
-}
-
-GURL TabContents::GetAlternateErrorPageURL() const {
-  GURL url;
-  // Disable alternate error pages when in OffTheRecord/Incognito mode.
-  if (profile()->IsOffTheRecord())
-    return url;
-
-  PrefService* prefs = profile()->GetPrefs();
-  DCHECK(prefs);
-  if (prefs->GetBoolean(prefs::kAlternateErrorPagesEnabled)) {
-    url = google_util::AppendGoogleLocaleParam(
-        GURL(google_util::kLinkDoctorBaseURL));
-    url = google_util::AppendGoogleTLDParam(url);
-  }
-  return url;
-}
-
-WebPreferences TabContents::GetWebkitPrefs() {
-  Profile* profile = render_view_host()->process()->profile();
-  bool is_web_ui = false;
-  WebPreferences web_prefs =
-      RenderViewHostDelegateHelper::GetWebkitPrefs(profile, is_web_ui);
-
-  // Force accelerated compositing and 2d canvas off for chrome: and
-  // chrome-extension: pages.
-  if (GetURL().SchemeIs(chrome::kChromeDevToolsScheme) ||
-      GetURL().SchemeIs(chrome::kChromeUIScheme)) {
-    web_prefs.accelerated_compositing_enabled = false;
-    web_prefs.accelerated_2d_canvas_enabled = false;
-  }
-
-#if defined(OS_MACOSX)
-  // Disable accelerated compositing if IOSurface's are not supported,
-  // as is the case in 10.5.
-  if (!IOSurfaceSupport::Initialize())
-      web_prefs.accelerated_compositing_enabled = false;
-#endif
-
-  return web_prefs;
-}
-
-void TabContents::OnUserGesture() {
-  // See comment in RenderViewHostDelegate::OnUserGesture as to why we do this.
-  DownloadRequestLimiter* limiter =
-      g_browser_process->download_request_limiter();
-  if (limiter)
-    limiter->OnUserGesture(this);
-  ExternalProtocolHandler::PermitLaunchUrl();
-}
-
-void TabContents::OnIgnoredUIEvent() {
-  if (constrained_window_count()) {
-    ConstrainedWindow* window = *constrained_window_begin();
-    window->FocusConstrainedWindow();
-  }
-}
-
-void TabContents::OnJSOutOfMemory() {
-  AddInfoBar(new SimpleAlertInfoBarDelegate(this, NULL,
-      l10n_util::GetStringUTF16(IDS_JS_OUT_OF_MEMORY_PROMPT), true));
-}
-
-void TabContents::OnCrossSiteResponse(int new_render_process_host_id,
-                                      int new_request_id) {
-  // Allows the TabContents to react when a cross-site response is ready to be
-  // delivered to a pending RenderViewHost.  We must first run the onunload
-  // handler of the old RenderViewHost before we can allow it to proceed.
-  render_manager_.OnCrossSiteResponse(new_render_process_host_id,
-                                      new_request_id);
-}
-
-void TabContents::RendererUnresponsive(RenderViewHost* rvh,
-                                       bool is_during_unload) {
-  if (is_during_unload) {
-    // Hang occurred while firing the beforeunload/unload handler.
-    // Pretend the handler fired so tab closing continues as if it had.
-    rvh->set_sudden_termination_allowed(true);
-
-    if (!render_manager_.ShouldCloseTabOnUnresponsiveRenderer())
-      return;
-
-    // If the tab hangs in the beforeunload/unload handler there's really
-    // nothing we can do to recover. Pretend the unload listeners have
-    // all fired and close the tab. If the hang is in the beforeunload handler
-    // then the user will not have the option of cancelling the close.
-    Close(rvh);
-    return;
-  }
-
-  if (render_view_host() && render_view_host()->IsRenderViewLive() &&
-      (!delegate() || delegate()->ShouldShowHungRendererDialog())) {
-    hung_renderer_dialog::ShowForTabContents(this);
-  }
-}
-
-void TabContents::RendererResponsive(RenderViewHost* render_view_host) {
-  hung_renderer_dialog::HideForTabContents(this);
-}
-
-void TabContents::LoadStateChanged(const GURL& url,
-                                   net::LoadState load_state,
-                                   uint64 upload_position,
-                                   uint64 upload_size) {
-  load_state_ = load_state;
-  upload_position_ = upload_position;
-  upload_size_ = upload_size;
-  std::wstring languages =
-      UTF8ToWide(profile()->GetPrefs()->GetString(prefs::kAcceptLanguages));
-  std::string host = url.host();
-  load_state_host_ = WideToUTF16Hack(
-      net::IDNToUnicode(host.c_str(), host.size(), languages, NULL));
-  if (load_state_ == net::LOAD_STATE_READING_RESPONSE)
-    SetNotWaitingForResponse();
-  if (is_loading())
-    NotifyNavigationStateChanged(INVALIDATE_LOAD | INVALIDATE_TAB);
-}
-
-bool TabContents::IsExternalTabContainer() const {
-  if (!delegate())
-    return false;
-
-  return delegate()->IsExternalTabContainer();
-}
-
-void TabContents::DidInsertCSS() {
-  // This RVHDelegate function is used for extensions and not us.
-}
-
-void TabContents::FocusedNodeChanged(bool is_editable_node) {
-  NotificationService::current()->Notify(
-      NotificationType::FOCUS_CHANGED_IN_PAGE,
-      Source<TabContents>(this),
-      Details<const bool>(&is_editable_node));
-}
-
-void TabContents::UpdateZoomLimits(int minimum_percent,
-                                   int maximum_percent,
-                                   bool remember) {
-  minimum_zoom_percent_ = minimum_percent;
-  maximum_zoom_percent_ = maximum_percent;
-  temporary_zoom_settings_ = !remember;
-}
-
-void TabContents::WorkerCrashed() {
-  AddInfoBar(new SimpleAlertInfoBarDelegate(this, NULL,
-      l10n_util::GetStringUTF16(IDS_WEBWORKER_CRASHED_PROMPT), true));
-}
-
-void TabContents::BeforeUnloadFiredFromRenderManager(
-    bool proceed,
-    bool* proceed_to_fire_unload) {
-  if (delegate())
-    delegate()->BeforeUnloadFired(this, proceed, proceed_to_fire_unload);
-}
-
-void TabContents::DidStartLoadingFromRenderManager(
-      RenderViewHost* render_view_host) {
-  DidStartLoading();
-}
-
-void TabContents::RenderViewGoneFromRenderManager(
-    RenderViewHost* render_view_host) {
-  DCHECK(crashed_status_ != base::TERMINATION_STATUS_STILL_RUNNING);
-  RenderViewGone(render_view_host, crashed_status_, crashed_error_code_);
-}
-
-void TabContents::UpdateRenderViewSizeForRenderManager() {
-  // TODO(brettw) this is a hack. See TabContentsView::SizeContents.
-  gfx::Size size = view_->GetContainerSize();
-  // 0x0 isn't a valid window size (minimal window size is 1x1) but it may be
-  // here during container initialization and normal window size will be set
-  // later. In case of tab duplication this resizing to 0x0 prevents setting
-  // normal size later so just ignore it.
-  if (!size.IsEmpty())
-    view_->SizeContents(size);
-}
-
-void TabContents::NotifySwappedFromRenderManager() {
-  NotifySwapped();
-}
-
-NavigationController& TabContents::GetControllerForRenderManager() {
-  return controller();
-}
-
-WebUI* TabContents::CreateWebUIForRenderManager(const GURL& url) {
-  return WebUIFactory::CreateWebUIForURL(this, url);
-}
-
-NavigationEntry*
-TabContents::GetLastCommittedNavigationEntryForRenderManager() {
-  return controller_.GetLastCommittedEntry();
-}
-
-bool TabContents::CreateRenderViewForRenderManager(
-    RenderViewHost* render_view_host) {
-  RenderWidgetHostView* rwh_view = view_->CreateViewForWidget(render_view_host);
-
-  if (!render_view_host->CreateRenderView(string16()))
-    return false;
-
-  // Now that the RenderView has been created, we need to tell it its size.
-  rwh_view->SetSize(view_->GetContainerSize());
-
-  UpdateMaxPageIDIfNecessary(render_view_host->site_instance(),
-                             render_view_host);
-  return true;
-}
-
-void TabContents::Observe(NotificationType type,
-                          const NotificationSource& source,
-                          const NotificationDetails& details) {
-  switch (type.value) {
-    case NotificationType::PREF_CHANGED: {
-      std::string* pref_name_in = Details<std::string>(details).ptr();
-      DCHECK(Source<PrefService>(source).ptr() == profile()->GetPrefs());
-      if (*pref_name_in == prefs::kAlternateErrorPagesEnabled) {
-        UpdateAlternateErrorPageURL();
-      } else if ((*pref_name_in == prefs::kDefaultCharset) ||
-                 StartsWithASCII(*pref_name_in, "webkit.webprefs.", true)) {
-        UpdateWebPreferences();
-      } else if (*pref_name_in == prefs::kDefaultZoomLevel) {
-        UpdateZoomLevel();
-      } else {
-        NOTREACHED() << "unexpected pref change notification" << *pref_name_in;
-      }
-      break;
-    }
-    case NotificationType::RENDER_WIDGET_HOST_DESTROYED:
-      view_->RenderWidgetHostDestroyed(Source<RenderWidgetHost>(source).ptr());
-      break;
-
-    case NotificationType::NAV_ENTRY_COMMITTED: {
-      DCHECK(&controller_ == Source<NavigationController>(source).ptr());
-
-      NavigationController::LoadCommittedDetails& committed_details =
-          *(Details<NavigationController::LoadCommittedDetails>(details).ptr());
-      ExpireInfoBars(committed_details);
-      break;
-    }
-
-#if defined(OS_LINUX)
-    case NotificationType::BROWSER_THEME_CHANGED: {
-      renderer_preferences_util::UpdateFromSystemSettings(
-          &renderer_preferences_, profile());
-      render_view_host()->SyncRendererPrefs();
-      break;
-    }
-#endif
-
-    case NotificationType::USER_STYLE_SHEET_UPDATED:
-      UpdateWebPreferences();
-      break;
-
-    case NotificationType::CONTENT_SETTINGS_CHANGED: {
-      Details<const ContentSettingsDetails> settings_details(details);
-      NavigationEntry* entry = controller_.GetActiveEntry();
-      GURL entry_url;
-      if (entry)
-        entry_url = entry->url();
-      if (settings_details.ptr()->update_all() ||
-          settings_details.ptr()->pattern().Matches(entry_url)) {
-        render_view_host()->SendContentSettings(entry_url,
-            profile()->GetHostContentSettingsMap()->
-                GetContentSettings(entry_url));
-      }
-      break;
-    }
-
-    case NotificationType::EXTENSION_LOADED:
-      break;
-
-    case NotificationType::EXTENSION_UNLOADED:
-      break;
-
-    case NotificationType::GOOGLE_URL_UPDATED:
-      UpdateAlternateErrorPageURL();
-      break;
-
-    default:
-      NOTREACHED();
-  }
-}
-
-void TabContents::UpdateExtensionAppIcon(const Extension* extension) {
-  extension_app_icon_.reset();
-
-  if (extension) {
-    extension_app_image_loader_.reset(new ImageLoadingTracker(this));
-    extension_app_image_loader_->LoadImage(
-        extension,
-        extension->GetIconResource(Extension::EXTENSION_ICON_SMALLISH,
-                                   ExtensionIconSet::MATCH_EXACTLY),
-        gfx::Size(Extension::EXTENSION_ICON_SMALLISH,
-                  Extension::EXTENSION_ICON_SMALLISH),
-        ImageLoadingTracker::CACHE);
-  } else {
-    extension_app_image_loader_.reset(NULL);
-  }
-}
-
-const Extension* TabContents::GetExtensionContaining(const GURL& url) {
-  ExtensionService* extensions_service = profile()->GetExtensionService();
-  if (!extensions_service)
-    return NULL;
-
-  const Extension* extension = extensions_service->GetExtensionByURL(url);
-  return extension ?
-      extension : extensions_service->GetExtensionByWebExtent(url);
-}
-
-void TabContents::OnImageLoaded(SkBitmap* image, ExtensionResource resource,
-                                int index) {
-  if (image) {
-    extension_app_icon_ = *image;
-    NotifyNavigationStateChanged(INVALIDATE_TAB);
-  }
-}
-
-gfx::NativeWindow TabContents::GetMessageBoxRootWindow() {
-  return view_->GetTopLevelNativeWindow();
-}
-
-void TabContents::OnMessageBoxClosed(IPC::Message* reply_msg,
-                                     bool success,
-                                     const std::wstring& prompt) {
-  last_javascript_message_dismissal_ = base::TimeTicks::Now();
-  if (is_showing_before_unload_dialog_ && !success) {
-    // If a beforeunload dialog is canceled, we need to stop the throbber from
-    // spinning, since we forced it to start spinning in Navigate.
-    DidStopLoading();
-
-    tab_close_start_time_ = base::TimeTicks();
-  }
-  is_showing_before_unload_dialog_ = false;
-  render_view_host()->JavaScriptMessageBoxClosed(reply_msg, success, prompt);
-}
-
-void TabContents::SetSuppressMessageBoxes(bool suppress_message_boxes) {
-  set_suppress_javascript_messages(suppress_message_boxes);
-}
-
-TabContents* TabContents::AsTabContents() {
-  return this;
-}
-
-ExtensionHost* TabContents::AsExtensionHost() {
-  return NULL;
-}
-
-void TabContents::set_encoding(const std::string& encoding) {
-  encoding_ = CharacterEncoding::GetCanonicalEncodingNameByAliasName(encoding);
-}
-
-void TabContents::SetAppIcon(const SkBitmap& app_icon) {
-  app_icon_ = app_icon;
-  NotifyNavigationStateChanged(INVALIDATE_TITLE);
-}
-
-void TabContents::SwapInRenderViewHost(RenderViewHost* rvh) {
-  render_manager_.SwapInRenderViewHost(rvh);
-}
-
-void TabContents::CreateViewAndSetSizeForRVH(RenderViewHost* rvh) {
-  RenderWidgetHostView* rwh_view = view()->CreateViewForWidget(rvh);
-  rwh_view->SetSize(view()->GetContainerSize());
-}
-
-bool TabContents::MaybeUsePreloadedPage(const GURL& url) {
-  prerender::PrerenderManager* pm = profile()->GetPrerenderManager();
-  if (pm != NULL) {
-    if (pm->MaybeUsePreloadedPage(this, url))
-      return true;
-  }
-  return false;
-}