Merge 136205 - Support scheme-setting for GoogleURLTracker.

chrome/browser/google/google_url_tracker.cc

 // Copyright (c) 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/google/google_url_tracker.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 27 matching lines @@
 
 GoogleURLTrackerInfoBarDelegate* CreateInfoBar(
     InfoBarTabHelper* infobar_helper,
     const GURL& search_url,
     GoogleURLTracker* google_url_tracker,
     const GURL& new_google_url) {
   return new GoogleURLTrackerInfoBarDelegate(infobar_helper, search_url,
       google_url_tracker, new_google_url);
 }
 
+string16 GetHost(const GURL& url) {
+  DCHECK(url.is_valid());
+  return net::StripWWW(UTF8ToUTF16(url.host()));
+}
+
 }  // namespace
 
 // GoogleURLTrackerInfoBarDelegate --------------------------------------------
 
 GoogleURLTrackerInfoBarDelegate::GoogleURLTrackerInfoBarDelegate(
     InfoBarTabHelper* infobar_helper,
     const GURL& search_url,
     GoogleURLTracker* google_url_tracker,
     const GURL& new_google_url)
     : ConfirmInfoBarDelegate(infobar_helper),
       map_key_(infobar_helper),
       search_url_(search_url),
       google_url_tracker_(google_url_tracker),
       new_google_url_(new_google_url),
       showing_(false) {
 }
 
 bool GoogleURLTrackerInfoBarDelegate::Accept() {
-  google_url_tracker_->AcceptGoogleURL(new_google_url_);
+  google_url_tracker_->AcceptGoogleURL(new_google_url_, true);
   return false;
 }
 
 bool GoogleURLTrackerInfoBarDelegate::Cancel() {
   google_url_tracker_->CancelGoogleURL(new_google_url_);
   return false;
 }
 
 string16 GoogleURLTrackerInfoBarDelegate::GetLinkText() const {
   return l10n_util::GetStringUTF16(IDS_LEARN_MORE);
 }
 
 bool GoogleURLTrackerInfoBarDelegate::LinkClicked(
     WindowOpenDisposition disposition) {
   content::OpenURLParams params(google_util::AppendGoogleLocaleParam(GURL(
       "https://www.google.com/support/chrome/bin/answer.py?answer=1618699")),
       content::Referrer(),
       (disposition == CURRENT_TAB) ? NEW_FOREGROUND_TAB : disposition,
       content::PAGE_TRANSITION_LINK, false);
   owner()->web_contents()->OpenURL(params);
   return false;
 }
 
+void GoogleURLTrackerInfoBarDelegate::SetGoogleURL(const GURL& new_google_url) {
+  DCHECK_EQ(GetHost(new_google_url_), GetHost(new_google_url));
+  new_google_url_ = new_google_url;
+}
+
 void GoogleURLTrackerInfoBarDelegate::Show() {
   showing_ = true;
   owner()->AddInfoBar(this);  // May delete |this| on failure!
 }
 
 void GoogleURLTrackerInfoBarDelegate::Close(bool redo_search) {
   if (redo_search) {
     // Re-do the user's search on the new domain.
     url_canon::Replacements<char> replacements;
     const std::string& host(new_google_url_.host());
@@ skipping 30 matching lines @@
     owner()->RemoveInfoBar(this);
 }
 
 GoogleURLTrackerInfoBarDelegate::~GoogleURLTrackerInfoBarDelegate() {
   if (google_url_tracker_)
     google_url_tracker_->InfoBarClosed(map_key_);
 }
 
 string16 GoogleURLTrackerInfoBarDelegate::GetMessageText() const {
   return l10n_util::GetStringFUTF16(IDS_GOOGLE_URL_TRACKER_INFOBAR_MESSAGE,
-                                    GetHost(true), GetHost(false));
+      GetHost(new_google_url_), GetHost(google_url_tracker_->google_url_));
 }
 
 string16 GoogleURLTrackerInfoBarDelegate::GetButtonLabel(
     InfoBarButton button) const {
   bool new_host = (button == BUTTON_OK);
   return l10n_util::GetStringFUTF16(new_host ?
       IDS_GOOGLE_URL_TRACKER_INFOBAR_SWITCH :
-      IDS_GOOGLE_URL_TRACKER_INFOBAR_DONT_SWITCH, GetHost(new_host));
-}
-
-string16 GoogleURLTrackerInfoBarDelegate::GetHost(bool new_host) const {
-  return net::StripWWW(UTF8ToUTF16(
-      (new_host ? new_google_url_ : google_url_tracker_->google_url_).host()));
+      IDS_GOOGLE_URL_TRACKER_INFOBAR_DONT_SWITCH,
+      GetHost(new_host ? new_google_url_ : google_url_tracker_->google_url_));
 }
 
 
 // GoogleURLTracker -----------------------------------------------------------
 
 const char GoogleURLTracker::kDefaultGoogleHomepage[] =
     "http://www.google.com/";
 const char GoogleURLTracker::kSearchDomainCheckURL[] =
-    "https://www.google.com/searchdomaincheck?format=domain&type=chrome";
+    "https://www.google.com/searchdomaincheck?format=url&type=chrome";
 
 GoogleURLTracker::GoogleURLTracker(Profile* profile, Mode mode)
     : profile_(profile),
       infobar_creator_(&CreateInfoBar),
       google_url_(mode == UNIT_TEST_MODE ? kDefaultGoogleHomepage :
           profile->GetPrefs()->GetString(prefs::kLastKnownGoogleURL)),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)),
       fetcher_id_(0),
       in_startup_sleep_(true),
       already_fetched_(false),
@@ skipping 39 matching lines @@
     tracker->SetNeedToFetch();
 }
 
 // static
 void GoogleURLTracker::GoogleURLSearchCommitted(Profile* profile) {
   GoogleURLTracker* tracker = GoogleURLTrackerFactory::GetForProfile(profile);
   if (tracker)
     tracker->SearchCommitted();
 }
 
-void GoogleURLTracker::AcceptGoogleURL(const GURL& new_google_url) {
+void GoogleURLTracker::AcceptGoogleURL(const GURL& new_google_url,
+                                       bool redo_searches) {
   google_url_ = new_google_url;
   PrefService* prefs = profile_->GetPrefs();
   prefs->SetString(prefs::kLastKnownGoogleURL, google_url_.spec());
   prefs->SetString(prefs::kLastPromptedGoogleURL, google_url_.spec());
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_GOOGLE_URL_UPDATED,
       content::Source<Profile>(profile_),
       content::Details<const GURL>(&new_google_url));
   need_to_prompt_ = false;
-  CloseAllInfoBars(true);
+  CloseAllInfoBars(redo_searches);
 }
 
 void GoogleURLTracker::CancelGoogleURL(const GURL& new_google_url) {
   profile_->GetPrefs()->SetString(prefs::kLastPromptedGoogleURL,
                                   new_google_url.spec());
   need_to_prompt_ = false;
   CloseAllInfoBars(false);
 }
 
 void GoogleURLTracker::InfoBarClosed(const InfoBarTabHelper* infobar_helper) {
@@ skipping 51 matching lines @@
 void GoogleURLTracker::OnURLFetchComplete(const content::URLFetcher* source) {
   // Delete the fetcher on this function's exit.
   scoped_ptr<content::URLFetcher> clean_up_fetcher(fetcher_.release());
 
   // Don't update the URL if the request didn't succeed.
   if (!source->GetStatus().is_success() || (source->GetResponseCode() != 200)) {
     already_fetched_ = false;
     return;
   }
 
-  // See if the response data was one we want to use, and if so, convert to the
-  // appropriate Google base URL.
+  // See if the response data was valid.  It should be
+  // "<scheme>://[www.]google.<TLD>/".
   std::string url_str;
   source->GetResponseAsString(&url_str);
   TrimWhitespace(url_str, TRIM_ALL, &url_str);
-
-  if (!StartsWithASCII(url_str, ".google.", false))
+  GURL url(url_str);
+  if (!url.is_valid() || (url.path().length() > 1) || url.has_query() ||
+      url.has_ref() ||
+      !google_util::IsGoogleDomainUrl(url.spec(),
+                                      google_util::DISALLOW_SUBDOMAIN))
     return;
 
-  fetched_google_url_ = GURL("http://www" + url_str);
+  std::swap(url, fetched_google_url_);
   GURL last_prompted_url(
       profile_->GetPrefs()->GetString(prefs::kLastPromptedGoogleURL));
 
   if (last_prompted_url.is_empty()) {
     // On the very first run of Chrome, when we've never looked up the URL at
     // all, we should just silently switch over to whatever we get immediately.
-    AcceptGoogleURL(fetched_google_url_);
+    AcceptGoogleURL(fetched_google_url_, true);  // Second arg is irrelevant.
     return;
   }
 
-  // If the URL hasn't changed, then whether |need_to_prompt_| is true or false,
-  // nothing has changed, so just bail.
-  if (fetched_google_url_ == last_prompted_url)
-    return;
+  string16 fetched_host(GetHost(fetched_google_url_));
+  if (fetched_google_url_ == google_url_) {
+    // Either the user has continually been on this URL, or we prompted for a
+    // different URL but have now changed back before they responded to any of
+    // the prompts.  In this latter case we want to close any open infobars and
+    // stop prompting.
+    CancelGoogleURL(fetched_google_url_);
+  } else if (fetched_host == GetHost(google_url_)) {
+    // Similar to the above case, but this time the new URL differs from the
+    // existing one, probably due to switching between HTTP and HTTPS searching.
+    // Like before we want to close any open infobars and stop prompting; we
+    // also want to silently accept the change in scheme.  We don't redo open
+    // searches so as to avoid suddenly changing a page the user might be
+    // interacting with; it's enough to simply get future searches right.
+    AcceptGoogleURL(fetched_google_url_, false);
+  } else if (fetched_host == GetHost(last_prompted_url)) {
+    // We've re-fetched a TLD the user previously turned down.  Although the new
+    // URL might have a different scheme than the old, we want to preserve the
+    // user's decision.  Note that it's possible that, like in the above two
+    // cases, we fetched yet another different URL in the meantime, which we
+    // have open infobars prompting about; in this case, as in those above, we
+    // want to go ahead and close the infobars and stop prompting, since we've
+    // switched back away from that URL.
+    CancelGoogleURL(fetched_google_url_);
+  } else {
+    // We've fetched a URL with a different TLD than the user is currently using
+    // or was previously prompted about.  This means we need to prompt again.
+    need_to_prompt_ = true;
 
-  if (fetched_google_url_ == google_url_) {
-    // The user came back to their original location after having temporarily
-    // moved.  Reset the prompted URL so we'll prompt again if they move again.
-    CancelGoogleURL(fetched_google_url_);
-    return;
+    // As in all the above cases, there could be open infobars prompting about
+    // some URL.  If these URLs have the same TLD, we can simply leave the
+    // existing infobars open and quietly point their "new Google URL"s at the
+    // new URL (for e.g. scheme changes).  Otherwise we go ahead and close the
+    // existing infobars since their message is out-of-date.
+    if (!url.is_valid())  // Note: |url| is the previous |fetched_google_url_|.
+      return;
+    if (fetched_host != GetHost(url)) {
+      CloseAllInfoBars(false);
+    } else if (fetched_google_url_ != url) {
+      for (InfoBarMap::iterator i(infobar_map_.begin());
+           i != infobar_map_.end(); ++i)
+        i->second->SetGoogleURL(fetched_google_url_);
+    }
   }
-
-  need_to_prompt_ = true;
-
-  // Any open infobars are pointing at the wrong Google URL.  (This can happen
-  // if an infobar has been sitting open and then our IP address changes.)
-  CloseAllInfoBars(false);
 }
 
 void GoogleURLTracker::Observe(int type,
                                const content::NotificationSource& source,
                                const content::NotificationDetails& details) {
   switch (type) {
     case content::NOTIFICATION_NAV_ENTRY_PENDING: {
       content::NavigationController* controller =
           content::Source<content::NavigationController>(source).ptr();
       content::WebContents* contents = controller->GetWebContents();
@@ skipping 123 matching lines @@
 
 void GoogleURLTracker::CloseAllInfoBars(bool redo_searches) {
   // Close all infobars, whether they've been added to tabs or not.
   while (!infobar_map_.empty())
     infobar_map_.begin()->second->Close(redo_searches);
 
   // Any registered listeners for NAV_ENTRY_COMMITTED and TAB_CLOSED are now
   // irrelevant as the associated infobars are gone.
   registrar_.RemoveAll();
 }