[Offline Prefetch] Pass api key to offline prefetch requests

components/offline_pages/core/prefetch/prefetch_request_fetcher.cc

 // Copyright 2017 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 "components/offline_pages/core/prefetch/prefetch_request_fetcher.h"
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
+#include "google_apis/google_api_keys.h"
 #include "net/base/load_flags.h"
+#include "net/base/url_util.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_status_code.h"
 #include "net/traffic_annotation/network_traffic_annotation.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_status.h"
 #include "url/gurl.h"
 
 namespace offline_pages {
 
 namespace {
 
-const char kPrefetchServer[] =
-    "http://staging-offlinepages-pa.sandbox.googleapis.com/";
+const char kPrefetchServer[] = "https://offlinepages-pa.googleapis.com/";
+const char kPrefetchStagingServer[] =
+    "https://staging-offlinepages-pa.sandbox.googleapis.com/";
+
+// Used in all offline prefetch request URLs to specify API Key.
+const char kApiKeyName[] = "key";
 
 // Content type needed in order to communicate with the server in binary
 // proto format.
 const char kRequestContentType[] = "application/x-protobuf";
 
-GURL CompleteURL(const std::string& url_path) {
+GURL CompleteURL(const std::string& url_path, version_info::Channel channel) {
+  bool is_stable_channel = channel == version_info::Channel::STABLE;
+  GURL server_url(is_stable_channel ? kPrefetchServer : kPrefetchStagingServer);
+
   GURL::Replacements replacements;
   replacements.SetPathStr(url_path);
-  return GURL(kPrefetchServer).ReplaceComponents(replacements);
+  GURL url = server_url.ReplaceComponents(replacements);
+
+  std::string api_key = is_stable_channel ? google_apis::GetAPIKey()
+                                          : google_apis::GetNonStableAPIKey();
+  return net::AppendQueryParameter(url, kApiKeyName, api_key);
 }
 
 }  // namespace
 
 // static
 std::unique_ptr<PrefetchRequestFetcher> PrefetchRequestFetcher::CreateForGet(
     const std::string& url_path,
+    version_info::Channel channel,
     net::URLRequestContextGetter* request_context_getter,
     const FinishedCallback& callback) {
   return base::WrapUnique(new PrefetchRequestFetcher(
-      url_path, std::string(), request_context_getter, callback));
+      url_path, std::string(), channel, request_context_getter, callback));
 }
 
 // static
 std::unique_ptr<PrefetchRequestFetcher> PrefetchRequestFetcher::CreateForPost(
     const std::string& url_path,
     const std::string& message,
+    version_info::Channel channel,
     net::URLRequestContextGetter* request_context_getter,
     const FinishedCallback& callback) {
   return base::WrapUnique(new PrefetchRequestFetcher(
-      url_path, message, request_context_getter, callback));
+      url_path, message, channel, request_context_getter, callback));
 }
 
 PrefetchRequestFetcher::PrefetchRequestFetcher(
     const std::string& url_path,
     const std::string& message,
+    version_info::Channel channel,
     net::URLRequestContextGetter* request_context_getter,
     const FinishedCallback& callback)
     : request_context_getter_(request_context_getter), callback_(callback) {
   net::NetworkTrafficAnnotationTag traffic_annotation =
       net::DefineNetworkTrafficAnnotation("offline_prefetch", R"(
         semantics {
           sender: "Offline Prefetch"
           description:
             "Chromium interacts with Offline Page Service to prefetch "
             "suggested website resources."
           trigger:
             "When there are suggested website resources to fetch."
           data:
             "URLs of the suggested website resources to fetch."
           destination: GOOGLE_OWNED_SERVICE
         }
         policy {
           cookies_allowed: false
           setting:
             "Users can enable or disable the offline prefetch by toggling"
             "chrome://flags#offline-prefetch in Chromium on Android."
           policy_exception_justification:
             "Not implemented, considered not useful."
         })");
   url_fetcher_ = net::URLFetcher::Create(
-      CompleteURL(url_path),
+      CompleteURL(url_path, channel),
       message.empty() ? net::URLFetcher::GET : net::URLFetcher::POST, this,
       traffic_annotation);
   url_fetcher_->SetRequestContext(request_context_getter_.get());
   url_fetcher_->SetAutomaticallyRetryOn5xx(false);
   url_fetcher_->SetAutomaticallyRetryOnNetworkChanges(0);
   if (message.empty()) {
     std::string extra_header(net::HttpRequestHeaders::kContentType);
     extra_header += ": ";
     extra_header += kRequestContentType;
     url_fetcher_->AddExtraRequestHeader(extra_header);
@@ skipping 38 matching lines @@
 
   if (!source->GetResponseAsString(data) || data->empty()) {
     DVLOG(1) << "Failed to get response or empty response";
     return PrefetchRequestStatus::SHOULD_RETRY_WITH_BACKOFF;
   }
 
   return PrefetchRequestStatus::SUCCESS;
 }
 
 }  // offline_pages