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_->GetPlatformVersionString()));
   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;
+  fingerprint->set_platform_version(delegate_->GetPlatformVersionString());
+  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);
+  HttpPost* http_post = new HttpPost(
+      url_context_getter,
+      copresence_server_host,
+      rpc_name,
+      command_line->GetSwitchValueASCII(switches::kCopresenceTracingToken),
+      delegate_->GetAPIKey(),
+      *request_proto);
+
   http_post->Start(base::Bind(callback, http_post));
   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