Moved theme related state from BrowserInstantController to InstantService.

chrome/browser/ui/search/instant_controller.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/search/instant_controller.h"
 
 #include <iterator>
 
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
@@ skipping 256 matching lines @@
       last_match_was_search_(false),
       omnibox_focus_state_(OMNIBOX_FOCUS_NONE),
       omnibox_focus_change_reason_(OMNIBOX_FOCUS_CHANGE_EXPLICIT),
       omnibox_bounds_(-1, -1, 0, 0),
       allow_overlay_to_show_search_suggestions_(false) {
 
   // When the InstantController lives, the InstantService should live.
   // InstantService sets up profile-level facilities such as the ThemeSource for
   // the NTP.
   // However, in some tests, browser_ may be null.
-  if (browser_)
-    InstantServiceFactory::GetForProfile(browser_->profile());
+  if (browser_) {
+    InstantService* instant_service = GetInstantService();
+    instant_service->AddObserver(this);
+  }
 }
 
 InstantController::~InstantController() {
+  if (browser_) {
+    InstantService* instant_service = GetInstantService();
+    instant_service->RemoveObserver(this);
+  }
 }
 
 void InstantController::OnAutocompleteStart() {
   if (UseTabForSuggestions() && instant_tab_->supports_instant()) {
     LOG_INSTANT_DEBUG_EVENT(
         this, "OnAutocompleteStart: using InstantTab");
     return;
   }
 
   // Not using |instant_tab_|. Check if overlay is OK to use.
@@ skipping 497 matching lines @@
       ResetNTP(GetLocalInstantURL());
   } else if (IsContentsFrom(overlay(), contents)) {
     LOG_INSTANT_DEBUG_EVENT(this, "InstantPageLoadFailed: overlay");
     bool is_local = overlay_->IsLocal();
     DeletePageSoon(overlay_.Pass());
     if (!is_local)
       ResetOverlay(GetLocalInstantURL());
   }
 }
 
+void InstantController::ThemeInfoChanged(
+    const ThemeBackgroundInfo& theme_info) {
+  if (!extended_enabled())
+    return;
+
+  if (overlay_ && GetOverlayContents() &&
+      SearchTabHelper::FromWebContents(overlay_->contents())->
+          UpdateLastKnownThemeBackgroundInfo(theme_info)) {
+    overlay_->SendThemeBackgroundInfo(theme_info);
+  }
+
+  if (ntp_ && ntp_->contents() &&
+      SearchTabHelper::FromWebContents(ntp_->contents())->
+          UpdateLastKnownThemeBackgroundInfo(theme_info)) {
+    ntp_->SendThemeBackgroundInfo(theme_info);
+  }
+
+  if (instant_tab_ && instant_tab_->contents() &&
+      SearchTabHelper::FromWebContents(instant_tab_->contents())->
+          UpdateLastKnownThemeBackgroundInfo(theme_info)) {
+    instant_tab_->SendThemeBackgroundInfo(theme_info);
+  }
+}
+
 content::WebContents* InstantController::GetOverlayContents() const {
   return overlay_ ? overlay_->contents() : NULL;
 }
 
 content::WebContents* InstantController::GetNTPContents() const {
   return ntp_ ? ntp_->contents() : NULL;
 }
 
 bool InstantController::IsOverlayingSearchResults() const {
   return model_.mode().is_search_suggestions() && IsFullHeight(model_) &&
@@ skipping 268 matching lines @@
 
   // Preload the Instant NTP.
   ntp_.reset();
   if (extended_enabled() && preload_ntp_)
     ResetNTP(GetInstantURL());
 
   if (instant_tab_)
     instant_tab_->SetDisplayInstantResults(instant_enabled_);
 }
 
-void InstantController::ThemeChanged(const ThemeBackgroundInfo& theme_info) {
-  if (!extended_enabled())
-    return;
-
-  if (overlay_)
-    overlay_->SendThemeBackgroundInfo(theme_info);
-  if (ntp_)
-    ntp_->SendThemeBackgroundInfo(theme_info);
-  if (instant_tab_)
-    instant_tab_->SendThemeBackgroundInfo(theme_info);
-}
-
 void InstantController::SwappedOverlayContents() {
   model_.SetOverlayContents(GetOverlayContents());
 }
 
 void InstantController::FocusedOverlayContents() {
 #if defined(USE_AURA)
   // On aura the omnibox only receives a focus lost if we initiate the focus
   // change. This does that.
   if (!model_.mode().is_default())
     browser_->InstantOverlayFocused();
 #endif
 }
 
 void InstantController::ReloadOverlayIfStale() {
   // The local overlay is never stale.
   if (overlay_ && (overlay_->IsLocal() || !overlay_->is_stale()))
     return;
 
   // If the overlay is showing or the omnibox has focus, don't refresh the
   // overlay. It will get refreshed the next time the overlay is hidden or the
   // omnibox loses focus.
   if (omnibox_focus_state_ == OMNIBOX_FOCUS_NONE && model_.mode().is_default())
     ResetOverlay(GetInstantURL());
 }
 
 void InstantController::OverlayLoadCompletedMainFrame() {
   if (overlay_->supports_instant())
     return;
-  InstantService* instant_service =
-      InstantServiceFactory::GetForProfile(browser_->profile());
+  InstantService* instant_service = GetInstantService();
   content::WebContents* contents = overlay_->contents();
   DCHECK(contents);
   if (instant_service->IsInstantProcess(
       contents->GetRenderProcessHost()->GetID())) {
     return;
   }
   InstantSupportDetermined(contents, false);
 }
 
 void InstantController::LogDebugEvent(const std::string& info) const {
   DVLOG(1) << info;
 
   debug_events_.push_front(std::make_pair(
       base::Time::Now().ToInternalValue(), info));
   static const size_t kMaxDebugEventSize = 2000;
   if (debug_events_.size() > kMaxDebugEventSize)
     debug_events_.pop_back();
 }
 
 void InstantController::ClearDebugEvents() {
   debug_events_.clear();
 }
 
 void InstantController::UpdateMostVisitedItems() {
-  InstantService* instant_service =
-      InstantServiceFactory::GetForProfile(profile());
+  InstantService* instant_service = GetInstantService();
   if (!instant_service)
     return;
 
   std::vector<InstantMostVisitedItem> items;
   instant_service->GetCurrentMostVisitedItems(&items);
 
   if (overlay_ && GetOverlayContents() &&
       SearchTabHelper::FromWebContents(overlay_->contents())->
           UpdateLastKnownMostVisitedItems(items)) {
     overlay_->SendMostVisitedItems(items);
@@ skipping 12 matching lines @@
   }
 
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_INSTANT_SENT_MOST_VISITED_ITEMS,
       content::Source<InstantController>(this),
       content::NotificationService::NoDetails());
 }
 
 void InstantController::DeleteMostVisitedItem(const GURL& url) {
   DCHECK(!url.is_empty());
-  InstantService* instant_service =
-      InstantServiceFactory::GetForProfile(profile());
+  InstantService* instant_service = GetInstantService();
   if (!instant_service)
     return;
 
   instant_service->DeleteMostVisitedItem(url);
 }
 
 void InstantController::UndoMostVisitedDeletion(const GURL& url) {
   DCHECK(!url.is_empty());
-  InstantService* instant_service =
-      InstantServiceFactory::GetForProfile(profile());
+  InstantService* instant_service = GetInstantService();
   if (!instant_service)
     return;
 
   instant_service->UndoMostVisitedDeletion(url);
 }
 
 void InstantController::UndoAllMostVisitedDeletions() {
-  InstantService* instant_service =
-      InstantServiceFactory::GetForProfile(profile());
+  InstantService* instant_service = GetInstantService();
   if (!instant_service)
     return;
 
   instant_service->UndoAllMostVisitedDeletions();
 }
 
 Profile* InstantController::profile() const {
   return browser_->profile();
 }
 
@@ skipping 10 matching lines @@
 }
 
 // TODO(shishir): We assume that the WebContent's current RenderViewHost is the
 // RenderViewHost being created which is not always true. Fix this.
 void InstantController::InstantPageRenderViewCreated(
     const content::WebContents* contents) {
   if (!extended_enabled())
     return;
 
   // Update theme info so that the page picks it up.
-  browser_->UpdateThemeInfo();
+  InstantService* instant_service = GetInstantService();
+  if (instant_service)
+    instant_service->UpdateThemeInfo();
 
   // Ensure the searchbox API has the correct initial state.
   if (IsContentsFrom(overlay(), contents)) {
     overlay_->SetDisplayInstantResults(instant_enabled_);
     overlay_->FocusChanged(omnibox_focus_state_, omnibox_focus_change_reason_);
     overlay_->SetOmniboxBounds(omnibox_bounds_);
     overlay_->InitializeFonts();
   } else if (IsContentsFrom(ntp(), contents)) {
     ntp_->SetDisplayInstantResults(instant_enabled_);
     ntp_->SetOmniboxBounds(omnibox_bounds_);
@@ skipping 416 matching lines @@
 
     // Hide the |overlay_| since we are now using |instant_tab_| instead.
     HideOverlay();
   } else {
     instant_tab_.reset();
   }
 }
 
 void InstantController::UpdateInfoForInstantTab() {
   if (instant_tab_) {
-    browser_->UpdateThemeInfo();
+    // Update theme details.
+    InstantService* instant_service = GetInstantService();
+    if (instant_service)
+      instant_service->UpdateThemeInfo();
+
     instant_tab_->SetDisplayInstantResults(instant_enabled_);
     instant_tab_->SetOmniboxBounds(omnibox_bounds_);
     instant_tab_->InitializeFonts();
     UpdateMostVisitedItems();
     instant_tab_->FocusChanged(omnibox_focus_state_,
                                omnibox_focus_change_reason_);
     instant_tab_->SetInputInProgress(IsInputInProgress());
   }
 }
 
@@ skipping 214 matching lines @@
   bool js_webkit_enabled = profile()->GetPrefs()->GetBoolean(
       prefs::kWebKitJavascriptEnabled);
   return js_content_enabled && js_webkit_enabled;
 }
 
 bool InstantController::InStartup() const {
   // TODO(shishir): This is not completely reliable. Find a better way to detect
   // startup time.
   return !browser_->GetActiveWebContents();
 }
+
+InstantService* InstantController::GetInstantService() const {
+  return InstantServiceFactory::GetForProfile(profile());
+}