Using API key specified from js

components/copresence/rpc/rpc_handler.cc

 // Copyright 2014 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/copresence/rpc/rpc_handler.h"
 
 #include <map>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 501 matching lines @@
     // TODO(ckehoe): Once we have the app ID from the server, we need to pass
     // it in here and get rid of the app id registry from the main API class.
     delegate_->HandleMessages("", subscription->first, subscription->second);
   }
 }
 
 RequestHeader* RpcHandler::CreateRequestHeader(
     const std::string& client_name) const {
   RequestHeader* header = new RequestHeader;
 
-  header->set_allocated_framework_version(
-      CreateVersion("Chrome", delegate_->GetPlatformVersionString()));
+  header->set_allocated_framework_version(CreateVersion(
+      "Chrome", delegate_->GetDeviceFingerprint().platform_version()));
   if (!client_name.empty()) {
     header->set_allocated_client_version(
         CreateVersion(client_name, std::string()));
   }
   header->set_current_time_millis(base::Time::Now().ToJsTime());
   header->set_registered_device_id(device_id_);
 
+  DeviceFingerprint* fingerprint =
+      new DeviceFingerprint(delegate_->GetDeviceFingerprint());
+  fingerprint->set_type(CHROME_PLATFORM_TYPE);
+  header->set_allocated_device_fingerprint(fingerprint);
+
   return header;
 }
 
 template <class T>
 void RpcHandler::SendServerRequest(
     const std::string& rpc_name,
     const std::string& app_id,
     scoped_ptr<T> request,
     const PostCleanupCallback& response_handler) {
   request->set_allocated_header(CreateRequestHeader(app_id));
   server_post_callback_.Run(delegate_->GetRequestContext(),
                             rpc_name,
                             make_scoped_ptr<MessageLite>(request.release()),
                             response_handler);
 }
 
 void RpcHandler::SendHttpPost(net::URLRequestContextGetter* url_context_getter,
                               const std::string& rpc_name,
                               scoped_ptr<MessageLite> request_proto,
                               const PostCleanupCallback& callback) {
   // Create the base URL to call.
   CommandLine* command_line = CommandLine::ForCurrentProcess();
   const std::string copresence_server_host =
       command_line->HasSwitch(switches::kCopresenceServer) ?
       command_line->GetSwitchValueASCII(switches::kCopresenceServer) :
       kDefaultCopresenceServer;
 
   // Create the request and keep a pointer until it completes.
-  const std::string& tracing_token =
-      command_line->GetSwitchValueASCII(switches::kCopresenceTracingToken);
   HttpPost* http_post = new HttpPost(url_context_getter,
                                      copresence_server_host,
-                                     rpc_name,
-                                     tracing_token,
-                                     *request_proto);
-  http_post->Start(base::Bind(callback, http_post));
+                                     rpc_name);
+
+  if (command_line->HasSwitch(switches::kCopresenceTracingToken)) {
+    http_post->set_tracing_token(
+        command_line->GetSwitchValueASCII(switches::kCopresenceTracingToken));
+  }
+  if (!delegate_->GetAPIKey().empty())
+    http_post->set_api_key(delegate_->GetAPIKey());

[rkc, 2014/08/13 21:45:31]

Why are we not just passing the API key in the constructor? If we don't have an
API, we can pass in an empty string (which the post checks for anyway).

[Charlie, 2014/08/13 22:53:37]

See previous comment. For Chrome, the API key is not required.

+
+  http_post->Start(base::Bind(callback, http_post), *request_proto);
   pending_posts_.insert(http_post);
 }
 
 void RpcHandler::AudioDirectiveListToWhispernetConnector(
     const std::string& token,
     bool audible,
     const WhispernetClient::SamplesCallback& samples_callback) {
   WhispernetClient* whispernet_client = delegate_->GetWhispernetClient();
   if (whispernet_client) {
     whispernet_client->RegisterSamplesCallback(samples_callback);
     whispernet_client->EncodeToken(token, audible);
   }
 }
 
 }  // namespace copresence