Reload Instant NTP and Instant-process tabs on search url change

chrome/browser/ui/search/instant_ntp_prerenderer.cc

 // Copyright 2013 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_ntp_prerenderer.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/prefs/pref_service.h"
@@ skipping 36 matching lines @@
 InstantNTPPrerenderer::InstantNTPPrerenderer(Profile* profile,
                                              PrefService* prefs)
     : profile_(profile) {
   DCHECK(profile);
 
   // In unit tests, prefs may be NULL.
   if (prefs) {
     profile_pref_registrar_.Init(prefs);
     profile_pref_registrar_.Add(
         prefs::kSearchSuggestEnabled,
-        base::Bind(&InstantNTPPrerenderer::ReloadStaleNTP,
-                   base::Unretained(this)));
-    profile_pref_registrar_.Add(
-        prefs::kDefaultSearchProviderID,
-        base::Bind(&InstantNTPPrerenderer::OnDefaultSearchProviderChanged,
+        base::Bind(&InstantNTPPrerenderer::ReloadInstantNTP,
                    base::Unretained(this)));
   }
   net::NetworkChangeNotifier::AddNetworkChangeObserver(this);
 }
 
 InstantNTPPrerenderer::~InstantNTPPrerenderer() {
   net::NetworkChangeNotifier::RemoveNetworkChangeObserver(this);
 }
 
-void InstantNTPPrerenderer::PreloadInstantNTP() {
-  DCHECK(!ntp());
-  ReloadStaleNTP();
+void InstantNTPPrerenderer::Init() {

[samarth, 2013/08/12 19:07:28]

Currently this function can be called multiple times: e.g., on mac, if you close
all windows without quitting Chrome and then open a new window. So you need to a
corresponding RemoveObserver call as well.

One option is to rename this to InitNTPContents and then add a RemoveObserver
call in DeleteNTPContents. You would also then need to double-check in the
destructor that ntp_ is NULL and if not, call DeleteNTPContents there.

Alternatively, you can Add in the constructor and Remove in the destructor but I
assume that doesn't work now because you can't look up InstantService in the
constructor (since it's the InstantService constructor that creates this class)?
If that's the case, you can pass in InstantService as an explicit argument to
the constructor here.

[Anuj, 2013/08/13 00:18:09]

Done.

+  InstantService* instant_service =
+      InstantServiceFactory::GetForProfile(profile_);
+  instant_service->AddObserver(this);
+  ReloadInstantNTP();
+}
+
+void InstantNTPPrerenderer::ReloadInstantNTP() {
+  ResetNTP(GetInstantURL());
 }
 
 scoped_ptr<content::WebContents> InstantNTPPrerenderer::ReleaseNTPContents() {
   if (!profile_ || profile_->IsOffTheRecord() ||
       !chrome::ShouldShowInstantNTP())
     return scoped_ptr<content::WebContents>();
 
   if (ShouldSwitchToLocalNTP())
     ResetNTP(GetLocalInstantURL());
 
   scoped_ptr<content::WebContents> ntp_contents = ntp_->ReleaseContents();
 
   // Preload a new InstantNTP.
-  ResetNTP(GetInstantURL());
+  ReloadInstantNTP();
   return ntp_contents.Pass();
 }
 
 content::WebContents* InstantNTPPrerenderer::GetNTPContents() const {
   return ntp() ? ntp()->contents() : NULL;
 }
 
 void InstantNTPPrerenderer::DeleteNTPContents() {
   if (ntp_)
     ntp_.reset();
@@ skipping 70 matching lines @@
   return ntp_.get();
 }
 
 void InstantNTPPrerenderer::OnNetworkChanged(
     net::NetworkChangeNotifier::ConnectionType type) {
   // Not interested in events conveying change to offline.
   if (type == net::NetworkChangeNotifier::CONNECTION_NONE)
     return;
 
   if (!ntp() || ntp()->IsLocal())
-    ResetNTP(GetInstantURL());
+    ReloadInstantNTP();
 }
 
 void InstantNTPPrerenderer::InstantSupportDetermined(
     const content::WebContents* contents,
     bool supports_instant) {
   DCHECK(ntp() && ntp()->contents() == contents);
 
   if (!supports_instant) {
     bool is_local = ntp()->IsLocal();
     DeleteNTPSoon(ntp_.Pass());
@@ skipping 41 matching lines @@
 void InstantNTPPrerenderer::InstantPageLoadFailed(
     content::WebContents* contents) {
   DCHECK(ntp() && ntp()->contents() == contents);
 
   bool is_local = ntp()->IsLocal();
   DeleteNTPSoon(ntp_.Pass());
   if (!is_local)
     ResetNTP(GetLocalInstantURL());
 }
 
-void InstantNTPPrerenderer::OnDefaultSearchProviderChanged(
-    const std::string& pref_name) {
-  DCHECK_EQ(pref_name, std::string(prefs::kDefaultSearchProviderID));
-  if (!ntp())
-    return;
-
-  ResetNTP(GetInstantURL());
-}
-
 void InstantNTPPrerenderer::ResetNTP(const std::string& instant_url) {
   // Instant NTP is only used in extended mode so we should always have a
   // non-empty URL to use.
   DCHECK(!instant_url.empty());
   ntp_.reset(new InstantNTP(this, instant_url, profile_));
-  ntp_->InitContents(base::Bind(&InstantNTPPrerenderer::ReloadStaleNTP,
+  ntp_->InitContents(base::Bind(&InstantNTPPrerenderer::ReloadInstantNTP,
                                 base::Unretained(this)));
 }
 
-void InstantNTPPrerenderer::ReloadStaleNTP() {
-  ResetNTP(GetInstantURL());
-}
-
 bool InstantNTPPrerenderer::PageIsCurrent() const {
   const std::string& instant_url = GetInstantURL();
   if (instant_url.empty() ||
       !chrome::MatchesOriginAndPath(GURL(ntp()->instant_url()),
                                     GURL(instant_url)))
     return false;
 
   return ntp()->supports_instant();
 }
 
@@ skipping 11 matching lines @@
     return false;
 
   if (PageIsCurrent())
     return false;
 
   // The preloaded NTP does not support instant yet. If we're not in startup,
   // always fall back to the local NTP. If we are in startup, use the local NTP
   // (unless the finch flag to use the remote NTP is set).
   return !(InStartup() && chrome::ShouldPreferRemoteNTPOnStartup());
 }
+
+////////////////////////////////////////////////////////////////////////////////
+// InstantNTPPrerenderer, InstantServiceObserver implementation:
+
+void InstantNTPPrerenderer::DefaultSearchProviderChanged() {
+  ReloadInstantNTP();
+}
+
+void InstantNTPPrerenderer::GoogleURLUpdated() {
+  ReloadInstantNTP();
+}