Adding support for authenticated copresence calls

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 42 matching lines @@
 const char kRegisterDeviceRpcName[] = "registerdevice";
 const char kDefaultCopresenceServer[] =
     "https://www.googleapis.com/copresence/v2/copresence";
 
 // Logging
 
 // Checks for a copresence error. If there is one, logs it and returns true.
 bool CopresenceErrorLogged(const Status& status) {
   if (status.code() != OK) {
     LOG(ERROR) << "Copresence error code " << status.code()
-               << (status.message().empty() ? std::string() :
-                  ": " + status.message());
+               << (status.message().empty() ? "" : ": " + status.message());
   }
   return status.code() != OK;
 }
 
 void LogIfErrorStatus(const util::error::Code& code,
                       const std::string& context) {
   LOG_IF(ERROR, code != util::error::OK)
       << context << " error " << code << ". See "
       << "cs/google3/util/task/codes.proto for more info.";
 }
@@ skipping 98 matching lines @@
   scoped_ptr<RegisterDeviceRequest> request(new RegisterDeviceRequest);
   DCHECK(device_id_.empty());
 
   request->mutable_push_service()->set_service(PUSH_SERVICE_NONE);
   Identity* identity =
       request->mutable_device_identifiers()->mutable_registrant();
   identity->set_type(CHROME);
   identity->set_chrome_id(base::GenerateGUID());
   SendServerRequest(
       kRegisterDeviceRpcName,
-      std::string(),
+      "",

[rkc, 2014/10/21 22:48:38]

std::string(), here and below.

[Charlie, 2014/10/21 23:19:44]

Done.

       request.Pass(),
       base::Bind(&RpcHandler::RegisterResponseHandler,
                  // On destruction, this request will be cancelled.
                  base::Unretained(this),
                  init_done_callback));
 }
 
 void RpcHandler::SendReportRequest(scoped_ptr<ReportRequest> request) {
-  SendReportRequest(request.Pass(), std::string(), StatusCallback());
+  SendReportRequest(request.Pass(), "", StatusCallback());
 }
 
 void RpcHandler::SendReportRequest(scoped_ptr<ReportRequest> request,
                                    const std::string& app_id,
                                    const StatusCallback& status_callback) {
   DCHECK(request.get());
   DCHECK(!device_id_.empty())
       << "RpcHandler::Initialize() must complete successfully "
       << "before other RpcHandler methods are called.";
 
@@ skipping 215 matching lines @@
 }
 
 RequestHeader* RpcHandler::CreateRequestHeader(
     const std::string& client_name) const {
   RequestHeader* header = new RequestHeader;
 
   header->set_allocated_framework_version(CreateVersion(
       "Chrome", delegate_->GetPlatformVersionString()));
   if (!client_name.empty()) {
     header->set_allocated_client_version(
-        CreateVersion(client_name, std::string()));
+        CreateVersion(client_name, ""));
   }
   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,
+                            app_id,
                             make_scoped_ptr<MessageLite>(request.release()),
                             response_handler);
 }
 
 void RpcHandler::SendHttpPost(net::URLRequestContextGetter* url_context_getter,
                               const std::string& rpc_name,
+                              const std::string& app_id,
                               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.
   HttpPost* http_post = new HttpPost(
       url_context_getter,
       copresence_server_host,
       rpc_name,
+      delegate_->GetAPIKey(app_id),
+      delegate_->GetAuthToken(app_id),
       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