Instant: Use only one hidden WebContents per profile.

chrome/browser/ui/browser.cc

 // Copyright 2012 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/ui/browser.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <shellapi.h>
 #endif  // defined(OS_WIN)
@@ skipping 41 matching lines @@
 #include "chrome/browser/download/download_shelf.h"
 #include "chrome/browser/extensions/browser_extension_window_controller.h"
 #include "chrome/browser/extensions/extension_prefs.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/tab_helper.h"
 #include "chrome/browser/favicon/favicon_tab_helper.h"
 #include "chrome/browser/file_select_helper.h"
 #include "chrome/browser/first_run/first_run.h"
 #include "chrome/browser/google/google_url_tracker.h"
+#include "chrome/browser/instant/instant_controller.h"
 #include "chrome/browser/lifetime/application_lifetime.h"
 #include "chrome/browser/net/url_fixer_upper.h"
 #include "chrome/browser/notifications/notification_ui_manager.h"
 #include "chrome/browser/pepper_broker_infobar_delegate.h"
 #include "chrome/browser/prefs/incognito_mode_prefs.h"
 #include "chrome/browser/printing/cloud_print/cloud_print_setup_flow.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_destroyer.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/profiles/profile_metrics.h"
@@ skipping 910 matching lines @@
 
 void Browser::TabDeactivated(WebContents* contents) {
   fullscreen_controller_->OnTabDeactivated(contents);
   search_delegate_->OnTabDeactivated(contents);
 
   // Save what the user's currently typing, so it can be restored when we
   // switch back to this tab.
   window_->GetLocationBar()->SaveStateToContents(contents);
 
   if (instant_controller_)
-    instant_controller_->TabDeactivated(contents);
+    instant_controller_->instant()->TabDeactivated(contents);
 }
 
 void Browser::ActiveTabChanged(WebContents* old_contents,
                                WebContents* new_contents,
                                int index,
                                bool user_gesture) {
   // On some platforms we want to automatically reload tabs that are
   // killed when the user selects them.
   bool did_reload = false;
   if (user_gesture && ShouldReloadCrashedTab(new_contents)) {
@@ skipping 51 matching lines @@
       SessionServiceFactory::GetForProfileIfExisting(profile_);
   if (session_service && !tab_strip_model_->closing_all()) {
     session_service->SetSelectedTabInWindow(session_id(),
                                             tab_strip_model_->active_index());
   }
 
   UpdateBookmarkBarState(BOOKMARK_BAR_STATE_CHANGE_TAB_SWITCH);
 
   // This needs to be called after UpdateSearchState().
   if (instant_controller_)
-    instant_controller_->ActiveTabChanged();
+    instant_controller_->instant()->ActiveTabChanged();
 }
 
 void Browser::TabMoved(WebContents* contents,
                        int from_index,
                        int to_index) {
   DCHECK(from_index >= 0 && to_index >= 0);
   // Notify the history service.
   SyncHistoryWithTabs(std::min(from_index, to_index));
 }
 
@@ skipping 123 matching lines @@
       GlobalErrorServiceFactory::GetForProfile(profile());
   GlobalError* error = service->GetFirstGlobalErrorWithBubbleView();
   if (error)
     error->ShowBubbleView(this);
 }
 
 void Browser::ShowFirstRunBubble() {
   window()->GetLocationBar()->ShowFirstRunBubble();
 }
 
-void Browser::MaybeUpdateBookmarkBarStateForInstantPreview(
-    const chrome::search::Mode& mode) {
+void Browser::MaybeUpdateBookmarkBarStateForInstantOverlay() {
   // This is invoked by a platform-specific implementation of
-  // |InstantPreviewController| to update bookmark bar state according to
-  // instant preview state.
+  // |InstantOverlayController| to update bookmark bar state according to
+  // Instant overlay state.
   // ModeChanged() updates bookmark bar state for all mode transitions except
   // when new mode is |SEARCH_SUGGESTIONS|, because that needs to be done when
   // the suggestions are ready.
-  if (mode.is_search_suggestions() &&
-      bookmark_bar_state_ == BookmarkBar::SHOW) {
+  if (bookmark_bar_state_ == BookmarkBar::SHOW)
     UpdateBookmarkBarState(BOOKMARK_BAR_STATE_CHANGE_TAB_STATE);
-  }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, content::WebContentsDelegate implementation:
 
 WebContents* Browser::OpenURLFromTab(WebContents* source,
                                      const OpenURLParams& params) {
   chrome::NavigateParams nav_params(this, params.url, params.transition);
   nav_params.source_contents = source;
   nav_params.referrer = params.referrer;
@@ skipping 578 matching lines @@
       break;
 
     default:
       NOTREACHED() << "Got a notification we didn't register for.";
   }
 }
 
 void Browser::ModeChanged(const chrome::search::Mode& old_mode,
                           const chrome::search::Mode& new_mode) {
   // If new mode is |SEARCH_SUGGESTIONS|, don't update bookmark bar state now;
-  // wait till the instant preview is ready to show suggestions before hiding
-  // the bookmark bar (in MaybeUpdateBookmarkBarStateForInstantPreview()).
+  // wait till the Instant overlay is ready to show suggestions before hiding
+  // the bookmark bar (in MaybeUpdateBookmarkBarStateForInstantOverlay()).
   // TODO(kuan): but for now, only delay updating bookmark bar state if origin
   // is |DEFAULT|; other origins require more complex logic to be implemented
   // to prevent jankiness caused by hiding bookmark bar, so just hide the
   // bookmark bar immediately and tolerate the jankiness for a while.
   // For other mode transitions, update bookmark bar state accordingly.
   if (new_mode.is_search_suggestions() &&
       new_mode.is_origin_default() &&
       bookmark_bar_state_ == BookmarkBar::SHOW) {
     return;
   }
   UpdateBookmarkBarState(BOOKMARK_BAR_STATE_CHANGE_TAB_STATE);
+
+  if (instant_controller_)
+    instant_controller_->instant()->SearchModeChanged(old_mode, new_mode);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, Command and state updating (private):
 
 void Browser::OnDevToolsDisabledChanged() {
   if (profile_->GetPrefs()->GetBoolean(prefs::kDevToolsDisabled))
     content::DevToolsManager::GetInstance()->CloseAllClientHosts();
 }
 
@@ skipping 129 matching lines @@
 
 void Browser::RemoveScheduledUpdatesFor(WebContents* contents) {
   if (!contents)
     return;
 
   UpdateMap::iterator i = scheduled_updates_.find(contents);
   if (i != scheduled_updates_.end())
     scheduled_updates_.erase(i);
 }
 
-
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, Getters for UI (private):
 
 StatusBubble* Browser::GetStatusBubble() {
   // In kiosk and exclusive app mode, we want to always hide the status bubble.
   if (chrome::IsRunningInAppMode())
     return NULL;
 
   return window_ ? window_->GetStatusBubble() : NULL;
 }
@@ skipping 149 matching lines @@
     state = BookmarkBar::HIDDEN;
 #endif
 
   if (state == bookmark_bar_state_)
     return;
 
   bookmark_bar_state_ = state;
 
   // Inform NTP page of change in bookmark bar state, so that it can adjust the
   // theme image top offset if necessary.
-  if (instant_controller_)
-    instant_controller_->UpdateThemeInfo(true);
+  if (instant_controller_) {
+    instant_controller_->instant()->BookmarkBarStateChanged(
+        bookmark_bar_state_ == BookmarkBar::DETACHED);
+  }
 
   if (!window_)
     return;  // This is called from the constructor when window_ is NULL.
 
   if (reason == BOOKMARK_BAR_STATE_CHANGE_TAB_SWITCH) {
     // Don't notify BrowserWindow on a tab switch as at the time this is invoked
     // BrowserWindow hasn't yet switched tabs. The BrowserWindow implementations
     // end up querying state once they process the tab switch.
     return;
   }
@@ skipping 84 matching lines @@
   if (contents && !allow_js_access) {
     contents->web_contents()->GetController().LoadURL(
         target_url,
         content::Referrer(),
         content::PAGE_TRANSITION_LINK,
         std::string());  // No extra headers.
   }
 
   return contents != NULL;
 }