Send API keys with translate API URL requests.

chrome/browser/translate/translate_manager.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/translate/translate_manager.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/json/json_reader.h"
@@ skipping 28 matching lines @@
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
+#include "google_apis/google_api_keys.h"
 #include "grit/browser_resources.h"
 #include "net/base/escape.h"
 #include "net/base/load_flags.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_request_status.h"
 #include "ui/base/layout.h"
 #include "ui/base/resource/resource_bundle.h"
 
 #ifdef FILE_MANAGER_EXTENSION
 #include "chrome/browser/chromeos/extensions/file_manager_util.h"
@@ skipping 103 matching lines @@
     "cb=cr.googleTranslate.onTranslateElementLoad&hl=%s";
 const char* const kTranslateScriptHeader =
     "Google-Translate-Element-Mode: library";
 const char* const kReportLanguageDetectionErrorURL =
     "https://translate.google.com/translate_error";
 const char* const kLanguageListFetchURL =
     "https://translate.googleapis.com/translate_a/l?client=chrome&cb=sl&hl=%s";
 const int kMaxRetryLanguageListFetch = 5;
 const int kTranslateScriptExpirationDelayDays = 1;
 
+void AddApiKeyToUrl(GURL* url) {
+  std::string api_key = google_apis::GetAPIKey();
+  if (!api_key.empty()) {

[Jói, 2012/09/13 16:25:02]

There is no need for this check.  If the key isn't specified, it will be
"dummytoken", not empty, and even if it is empty I think it should be OK to send
"&key=".

[MAD, 2012/09/13 17:23:21]

OK... Note that I copied the behavior from here:
http://108.166.104.54/xref/chromium/src/content/browser/geolocation/network_l...

Should we fix it there too?

+    std::string query(url->query());
+    if (!query.empty())
+      query += "&";
+    query += "key=" + net::EscapeQueryParamValue(api_key, true);
+    GURL::Replacements replacements;
+    replacements.SetQueryStr(query);
+    *url = url->ReplaceComponents(replacements);
+  }
+}
+
 }  // namespace
 
 // This must be kept in sync with the &cb= value in the kLanguageListFetchURL.
 const char* const TranslateManager::kLanguageListCallbackName = "sl(";
 const char* const TranslateManager::kTargetLanguagesKey = "tl";
 
 // static
 base::LazyInstance<std::set<std::string> >
     TranslateManager::supported_languages_ = LAZY_INSTANCE_INITIALIZER;
 
@@ skipping 474 matching lines @@
       web_contents->GetRenderViewHost()->GetRoutingID(), entry->GetPageID()));
 
   TranslateTabHelper* helper =
       TabContents::FromWebContents(web_contents)->translate_tab_helper();
   helper->language_state().set_current_language(
       helper->language_state().original_language());
 }
 
 void TranslateManager::ReportLanguageDetectionError(WebContents* web_contents) {
   UMA_HISTOGRAM_COUNTS("Translate.ReportLanguageDetectionError", 1);
-  GURL page_url = web_contents->GetController().GetActiveEntry()->GetURL();
-  // Report option should be disabled for secure URLs.
-  DCHECK(!page_url.SchemeIsSecure());
-  std::string report_error_url(kReportLanguageDetectionErrorURL);
-  report_error_url += "?client=cr&action=langidc&u=";
-  report_error_url += net::EscapeUrlEncodedData(page_url.spec(), true);
-  report_error_url += "&sl=";
-
-  TranslateTabHelper* helper =
-      TabContents::FromWebContents(web_contents)->translate_tab_helper();
-  report_error_url += helper->language_state().original_language();
-  report_error_url += "&hl=";
-  report_error_url +=
-      GetLanguageCode(g_browser_process->GetApplicationLocale());
-  // Open that URL in a new tab so that the user can tell us more.
+  // We'll open the URL in a new tab so that the user can tell us more.
   Browser* browser = browser::FindBrowserWithWebContents(web_contents);
   if (!browser) {
     NOTREACHED();
     return;
   }
-  chrome::AddSelectedTabWithURL(browser, GURL(report_error_url),
+
+  GURL page_url = web_contents->GetController().GetActiveEntry()->GetURL();
+  // Report option should be disabled for secure URLs.
+  DCHECK(!page_url.SchemeIsSecure());
+  std::string report_error_url_str(kReportLanguageDetectionErrorURL);
+  report_error_url_str += "?client=cr&action=langidc&u=";
+  report_error_url_str += net::EscapeUrlEncodedData(page_url.spec(), true);
+  report_error_url_str += "&sl=";
+
+  TranslateTabHelper* helper =
+      TabContents::FromWebContents(web_contents)->translate_tab_helper();
+  report_error_url_str += helper->language_state().original_language();
+  report_error_url_str += "&hl=";
+  report_error_url_str +=
+      GetLanguageCode(g_browser_process->GetApplicationLocale());
+
+  GURL report_error_url(report_error_url_str);
+  AddApiKeyToUrl(&report_error_url);
+  chrome::AddSelectedTabWithURL(browser, report_error_url,
                                 content::PAGE_TRANSITION_AUTO_BOOKMARK);
 }
 
 void TranslateManager::DoTranslatePage(WebContents* web_contents,
                                        const std::string& translate_script,
                                        const std::string& source_lang,
                                        const std::string& target_lang) {
   NavigationEntry* entry = web_contents->GetController().GetActiveEntry();
   if (!entry) {
     NOTREACHED();
@@ skipping 107 matching lines @@
     return;
 
   // We don't want to do this when translate is disabled.
   DCHECK(prefs != NULL);
   if (CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kDisableTranslate) ||
       (prefs != NULL && !prefs->GetBoolean(prefs::kEnableTranslate))) {
     return;
   }
 
-  std::string language_list_fetch_url = base::StringPrintf(
-      kLanguageListFetchURL,
-      GetLanguageCode(g_browser_process->GetApplicationLocale()).c_str());
+  GURL language_list_fetch_url = GURL(
+      base::StringPrintf(
+          kLanguageListFetchURL,
+          GetLanguageCode(g_browser_process->GetApplicationLocale()).c_str()));
+  AddApiKeyToUrl(&language_list_fetch_url);
   language_list_request_pending_.reset(net::URLFetcher::Create(
-      1, GURL(language_list_fetch_url), net::URLFetcher::GET, this));
+      1, language_list_fetch_url, net::URLFetcher::GET, this));
   language_list_request_pending_->SetLoadFlags(net::LOAD_DO_NOT_SEND_COOKIES |
                                                net::LOAD_DO_NOT_SAVE_COOKIES);
   language_list_request_pending_->SetRequestContext(
       g_browser_process->system_request_context());
   language_list_request_pending_->SetMaxRetries(kMaxRetryLanguageListFetch);
   language_list_request_pending_->Start();
 }
 
 void TranslateManager::CleanupPendingUlrFetcher() {
   language_list_request_pending_.reset();
   translate_script_request_pending_.reset();
 }
 
 void TranslateManager::RequestTranslateScript() {
   if (translate_script_request_pending_.get() != NULL)
     return;
 
-  std::string translate_script_url = base::StringPrintf(
+  GURL translate_script_url = GURL(base::StringPrintf(
       kTranslateScriptURL,
-      GetLanguageCode(g_browser_process->GetApplicationLocale()).c_str());
+      GetLanguageCode(g_browser_process->GetApplicationLocale()).c_str()));
+  AddApiKeyToUrl(&translate_script_url);
   translate_script_request_pending_.reset(net::URLFetcher::Create(
-      0, GURL(translate_script_url), net::URLFetcher::GET, this));
+      0, translate_script_url, net::URLFetcher::GET, this));
   translate_script_request_pending_->SetLoadFlags(
       net::LOAD_DO_NOT_SEND_COOKIES | net::LOAD_DO_NOT_SAVE_COOKIES);
   translate_script_request_pending_->SetRequestContext(
       g_browser_process->system_request_context());
   translate_script_request_pending_->SetExtraRequestHeaders(
       kTranslateScriptHeader);
   translate_script_request_pending_->Start();
 }
 
 void TranslateManager::ShowInfoBar(content::WebContents* web_contents,
@@ skipping 48 matching lines @@
   InfoBarTabHelper* infobar_helper = tab_contents->infobar_tab_helper();
 
   for (size_t i = 0; i < infobar_helper->GetInfoBarCount(); ++i) {
     TranslateInfoBarDelegate* delegate =
         infobar_helper->GetInfoBarDelegateAt(i)->AsTranslateInfoBarDelegate();
     if (delegate)
       return delegate;
   }
   return NULL;
 }