Switch to using the new Link Doctor API.

chrome/browser/google/google_util.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_util.h"
 
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/google/google_url_tracker.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/installer/util/google_update_settings.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "net/base/url_util.h"
 #include "url/gurl.h"
 
 #if defined(OS_MACOSX)
 #include "chrome/browser/mac/keystone_glue.h"
 #elif defined(OS_CHROMEOS)
 #include "chrome/browser/google/google_util_chromeos.h"
 #endif
 
+// Only use Link Doctor on official builds.  It uses an API key, too, but
+// seems best to just disable it, for more responsive error pages and to reduce
+// server load.
 #if defined(GOOGLE_CHROME_BUILD)
-#include "chrome/browser/google/linkdoctor_internal/linkdoctor_internal.h"
-#endif
-
-#ifndef LINKDOCTOR_SERVER_REQUEST_URL
-#define LINKDOCTOR_SERVER_REQUEST_URL std::string()
+#define LINKDOCTOR_SERVER_REQUEST_URL "https://www.googleapis.com/rpc"
+#else
+#define LINKDOCTOR_SERVER_REQUEST_URL ""
 #endif
 
 
 // Helpers --------------------------------------------------------------------
 
 namespace {
 
 const char* brand_for_testing = NULL;
 bool gUseMockLinkDoctorBaseURLForTesting = false;
 
@@ skipping 21 matching lines @@
 GURL LinkDoctorBaseURL() {
   if (gUseMockLinkDoctorBaseURLForTesting)
     return GURL("http://mock.linkdoctor.url/for?testing");
   return GURL(LINKDOCTOR_SERVER_REQUEST_URL);
 }
 
 void SetMockLinkDoctorBaseURLForTesting() {
   gUseMockLinkDoctorBaseURLForTesting = true;
 }
 
-GURL AppendGoogleLocaleParam(const GURL& url) {
-  // Google does not yet recognize 'nb' for Norwegian Bokmal, but it uses
-  // 'no' for that.

[Peter Kasting, 2014/02/04 22:49:04]

Why did you remove this comment?

[mmenke, 2014/02/04 23:52:02]

Mistake, thanks for catching that.

+std::string GetGoogleLocale() {
   std::string locale = g_browser_process->GetApplicationLocale();
   if (locale == "nb")
-    locale = "no";
-  return net::AppendQueryParameter(url, "hl", locale);
+    return "no";
+  return locale;
+}
+
+GURL AppendGoogleLocaleParam(const GURL& url) {
+  return net::AppendQueryParameter(url, "hl", GetGoogleLocale());
 }
 
 std::string StringAppendGoogleLocaleParam(const std::string& url) {
   GURL original_url(url);
   DCHECK(original_url.is_valid());
   GURL localized_url = AppendGoogleLocaleParam(original_url);
   return localized_url.spec();
 }
 
-GURL AppendGoogleTLDParam(Profile* profile, const GURL& url) {
+std::string GetGoogleCountryCodeCode(Profile* profile) {
   const std::string google_domain(
       net::registry_controlled_domains::GetDomainAndRegistry(
           GoogleURLTracker::GoogleURL(profile),
           net::registry_controlled_domains::EXCLUDE_PRIVATE_REGISTRIES));
-  const size_t first_dot = google_domain.find('.');
-  if (first_dot == std::string::npos) {
+  const size_t last_dot = google_domain.find_last_of('.');
+  if (last_dot == std::string::npos) {
     NOTREACHED();

[Peter Kasting, 2014/02/04 22:49:04]

Do not handle DCHECK failure.  Instead of "if (...) { NOTREACHED(); return",
just do DCHECK(...) and unconditionally move on.

[mmenke, 2014/02/04 23:52:02]

Done.  Looks like GoogleURLTracker is smart enough to ensure we don't get
something without any periods in it, but if it weren't, I'd argue that this code
would be the way to go, since we get the URL from a remote Google service, which
we wouldn't want to be able to crash Chrome.

[Peter Kasting, 2014/02/05 00:01:39]

If that were the case, we wouldn't want NOTREACHED(), since NOTREACHED() asserts
that it is impossible to reach under any condition.

[mmenke, 2014/02/05 00:04:56]

Makes sense.

-    return url;
+    return "";
   }
-  return net::AppendQueryParameter(url, "sd",
-                                   google_domain.substr(first_dot + 1));
+  std::string tld = google_domain.substr(last_dot + 1);

[Peter Kasting, 2014/02/04 22:49:04]

Nit: I'm uneasy calling this the "tld", since it's not, necessarily.  (The old
returned value, by contrast, was a real TLD.)

Perhaps this should be called the "country component".

[mmenke, 2014/02/04 23:52:02]

Done, though per IANA, uk is a TLD:
http://data.iana.org/TLD/tlds-alpha-by-domain.txt.  It's just not a registry
controlled domain.

I also removed the call to "registry_controlled_domains::GetDomainAndRegistry",
since it's no longer needed.  Switched to using the host.

+  // Assume the com TLD implies the US.
+  if (tld == "com")
+    return "us";
+  // The CLDR code for the UK is "GB".

[Peter Kasting, 2014/02/04 22:49:04]

What does "CLDR" mean?  Explain it or don't use this abbreviation.

[mmenke, 2014/02/04 23:52:02]

Done.

+  if (tld == "uk")
+    return "gb";
+  // Catalonia does not have a CLDR country code, so use Spain instead.
+  if (tld == "cat")
+    return "es";
+  return tld;
+}
+
+GURL GetGoogleSearchURL(Profile* profile) {
+  GURL url = GoogleURLTracker::GoogleURL(profile);

[Peter Kasting, 2014/02/04 22:49:04]

Nit: This can just be inlined into the last line of the function.

[mmenke, 2014/02/04 23:52:02]

Done.

+
+  // The url returned by the tracker does not include search path.

[Peter Kasting, 2014/02/04 22:49:04]

Nit: search path -> the "/search" path

[mmenke, 2014/02/04 23:52:02]

Done.

+  std::string search_path = "search";
+  GURL::Replacements replace_path;
+  replace_path.SetPathStr(search_path);
+  return url.ReplaceComponents(replace_path);
 }
 
 #if defined(OS_WIN)
 
 bool GetBrand(std::string* brand) {
   if (brand_for_testing) {
     brand->assign(brand_for_testing);
     return true;
   }
 
@@ skipping 171 matching lines @@
   DCHECK(brand_for_testing == NULL);
   brand_for_testing = brand_.c_str();
 }
 
 BrandForTesting::~BrandForTesting() {
   brand_for_testing = NULL;
 }
 
 
 }  // namespace google_util