Removing the project ID

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 "base/bind.h"
 #include "base/command_line.h"
 #include "base/guid.h"
 #include "base/logging.h"
@@ skipping 121 matching lines @@
   audible->add_instruction_type(RECEIVE);
 
   return state.Pass();
 }
 
 // TODO(ckehoe): We're keeping this code in a separate function for now
 // because we get a version string from Chrome, but the proto expects
 // an int64 version. We should probably change the version proto
 // to handle a more detailed version.
 ClientVersion* CreateVersion(const std::string& client,
-                             const std::string& version_name,
-                             const std::string& project_id) {
+                             const std::string& version_name) {
   ClientVersion* version = new ClientVersion;
-
   version->set_client(client);
   version->set_version_name(version_name);
-
-  if (!project_id.empty()) {
-    DVLOG(3) << "Using project ID " << project_id;
-    version->set_project_id(project_id);
-  }
-
   return version;
 }
 
 void AddTokenToRequest(const AudioToken& token, ReportRequest* request) {
   TokenObservation* token_observation =
       request->mutable_update_signals_request()->add_token_observation();
   token_observation->set_token_id(ToUrlSafe(token.token));
 
   TokenSignals* signals = token_observation->add_signals();
   signals->set_medium(token.audible ? AUDIO_AUDIBLE_DTMF
@@ skipping 42 matching lines @@
   for (HttpPost* post : pending_posts_)
     delete post;
 }
 
 void RpcHandler::SendReportRequest(scoped_ptr<ReportRequest> request,
                                    const std::string& app_id,
                                    const std::string& auth_token,
                                    const StatusCallback& status_callback) {
   DCHECK(request.get());
 
+  // Check that the app, if any, has some kind of authentication token.
+  // Don't allow it to piggyback on Chrome's credentials.
+  if (!app_id.empty() && delegate_->GetAPIKey(app_id).empty() &&
+      auth_token.empty()) {
+    LOG(ERROR) << "App " << app_id << " has no API key or auth token";
+    status_callback.Run(FAIL);
+    return;
+  }
+
   // Store just one auth token since we should have only one account
   // per instance of the copresence component.
   // TODO(ckehoe): We may eventually need to support multiple auth tokens.
   const bool authenticated = !auth_token.empty();
   if (authenticated && auth_token != auth_token_) {
     LOG_IF(ERROR, !auth_token_.empty())
         << "Overwriting old auth token: " << LoggingStrForToken(auth_token);
     auth_token_ = auth_token;
   }
 
@@ skipping 339 matching lines @@
 }
 
 // TODO(ckehoe): Pass in the version string and
 // group this with the local functions up top.
 RequestHeader* RpcHandler::CreateRequestHeader(
     const std::string& app_id,
     const std::string& device_id) const {
   RequestHeader* header = new RequestHeader;
 
   header->set_allocated_framework_version(CreateVersion(
-      "Chrome", delegate_->GetPlatformVersionString(), std::string()));
-  if (!app_id.empty()) {
-    LOG_IF(WARNING, delegate_->GetProjectId(app_id).empty())
-        << "No copresence project ID available";
-    header->set_allocated_client_version(CreateVersion(
-        app_id, std::string(), delegate_->GetProjectId(app_id)));
-  }
+      "Chrome", delegate_->GetPlatformVersionString()));
+  if (!app_id.empty())
+    header->set_allocated_client_version(CreateVersion(app_id, std::string()));
   header->set_current_time_millis(base::Time::Now().ToJsTime());
   if (!device_id.empty())
     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& device_id,
     const std::string& app_id,
     bool authenticated,
     scoped_ptr<T> request,
     const PostCleanupCallback& response_handler) {
   request->set_allocated_header(CreateRequestHeader(app_id, device_id));
   if (authenticated)
     DCHECK(!auth_token_.empty());
   server_post_callback_.Run(delegate_->GetRequestContext(),
                             rpc_name,
-                            delegate_->GetAPIKey(app_id),  // Deprecated
+                            delegate_->GetAPIKey(app_id),
                             authenticated ? auth_token_ : std::string(),
                             make_scoped_ptr<MessageLite>(request.release()),
                             response_handler);
 }
 
 void RpcHandler::SendHttpPost(net::URLRequestContextGetter* url_context_getter,
                               const std::string& rpc_name,
-                              const std::string& api_key,  // Deprecated
+                              const std::string& api_key,
                               const std::string& auth_token,
                               scoped_ptr<MessageLite> request_proto,
                               const PostCleanupCallback& callback) {
   // Create the base URL to call.
   base::CommandLine* command_line = base::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,
       api_key,
       auth_token,
       command_line->GetSwitchValueASCII(switches::kCopresenceTracingToken),
       *request_proto);
 
   http_post->Start(base::Bind(callback, http_post));
   pending_posts_.insert(http_post);
 }
 
 }  // namespace copresence