Using API key specified from js

components/copresence/rpc/rpc_handler_unittest.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 <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/message_loop/message_loop.h"
 #include "components/copresence/handlers/directive_handler.h"
 #include "components/copresence/proto/data.pb.h"
 #include "components/copresence/proto/enums.pb.h"
 #include "components/copresence/proto/rpcs.pb.h"
 #include "net/http/http_status_code.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using google::protobuf::MessageLite;
 using google::protobuf::RepeatedPtrField;
 
 namespace copresence {
 
 namespace {
 
+const char kChromeVersion[] = "Chrome Version String";
+
 void AddMessageWithStrategy(ReportRequest* report,
                             BroadcastScanConfiguration strategy) {
   report->mutable_manage_messages_request()->add_message_to_publish()
       ->mutable_token_exchange_strategy()->set_broadcast_scan_configuration(
           strategy);
 }
 
 void AddSubscriptionWithStrategy(ReportRequest* report,
                                  BroadcastScanConfiguration strategy) {
   report->mutable_manage_subscriptions_request()->add_subscription()
@@ skipping 38 matching lines @@
  private:
   std::vector<Directive> added_directives_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeDirectiveHandler);
 };
 
 }  // namespace
 
 class RpcHandlerTest : public testing::Test, public CopresenceClientDelegate {
  public:
-  RpcHandlerTest() : rpc_handler_(this), status_(SUCCESS) {
+  RpcHandlerTest() : rpc_handler_(this), status_(SUCCESS), api_key_("API key") {
     rpc_handler_.server_post_callback_ =
         base::Bind(&RpcHandlerTest::CaptureHttpPost, base::Unretained(this));
     rpc_handler_.device_id_ = "Device ID";
+
+    fingerprint_.set_platform_version(kChromeVersion);
   }
 
   void CaptureHttpPost(
       net::URLRequestContextGetter* url_context_getter,
       const std::string& rpc_name,
       scoped_ptr<MessageLite> request_proto,
       const RpcHandler::PostCleanupCallback& response_callback) {
     rpc_name_ = rpc_name;
     request_proto_ = request_proto.Pass();
   }
@@ skipping 60 matching lines @@
       const std::string& subscription_id,
       const std::vector<Message>& messages) OVERRIDE {
     // app_id is unused for now, pending a server fix.
     messages_by_subscription_[subscription_id] = messages;
   }
 
   virtual net::URLRequestContextGetter* GetRequestContext() const OVERRIDE {
     return NULL;
   }
 
-  virtual const std::string GetPlatformVersionString() const OVERRIDE {
-    return "Version String";
+  virtual const DeviceFingerprint& GetDeviceFingerprint() const OVERRIDE {
+    return fingerprint_;
+  }
+
+  virtual const std::string& GetAPIKey() const OVERRIDE {
+    return api_key_;
   }
 
   virtual WhispernetClient* GetWhispernetClient() OVERRIDE {
     return NULL;
   }
 
  protected:
   // For rpc_handler_.invalid_audio_token_cache_
   base::MessageLoop message_loop_;
 
   RpcHandler rpc_handler_;
+  CopresenceStatus status_;
+  std::string api_key_;
+  DeviceFingerprint fingerprint_;
 
   std::string rpc_name_;
   scoped_ptr<MessageLite> request_proto_;
-  CopresenceStatus status_;
   std::map<std::string, std::vector<Message> > messages_by_subscription_;
 };
 
 TEST_F(RpcHandlerTest, Initialize) {
   SetDeviceId("");
   rpc_handler_.Initialize(RpcHandler::SuccessCallback());
   RegisterDeviceRequest* registration =
       static_cast<RegisterDeviceRequest*>(request_proto_.get());
   Identity identity = registration->device_identifiers().registrant();
   EXPECT_EQ(CHROME, identity.type());
@@ skipping 83 matching lines @@
   EXPECT_EQ(OPTED_OUT, subscription_filter.allowed_opt_in_state(0));
 }
 
 TEST_F(RpcHandlerTest, CreateRequestHeader) {
   SetDeviceId("CreateRequestHeader Device ID");
   rpc_handler_.SendReportRequest(make_scoped_ptr(new ReportRequest),
                                  "CreateRequestHeader App ID",
                                  StatusCallback());
   EXPECT_EQ(RpcHandler::kReportRequestRpcName, rpc_name_);
   ReportRequest* report = static_cast<ReportRequest*>(request_proto_.get());
-  EXPECT_TRUE(report->header().has_framework_version());
+  EXPECT_EQ(kChromeVersion,
+            report->header().framework_version().version_name());
   EXPECT_EQ("CreateRequestHeader App ID",
             report->header().client_version().client());
   EXPECT_EQ("CreateRequestHeader Device ID",
             report->header().registered_device_id());
+  EXPECT_EQ(CHROME_PLATFORM_TYPE,
+            report->header().device_fingerprint().type());
 }
 
 // TODO(ckehoe): Renable these after https://codereview.chromium.org/453203002/
 // lands.
 #define MAYBE_ReportTokens DISABLED_ReportTokens
 
 TEST_F(RpcHandlerTest, MAYBE_ReportTokens) {
   std::vector<AudioToken> test_tokens;
   test_tokens.push_back(AudioToken("token 1", false));
   test_tokens.push_back(AudioToken("token 2", true));
@@ skipping 65 matching lines @@
             messages_by_subscription_["Subscription 2"][1].payload());
 
   ASSERT_EQ(2U, directive_handler->added_directives().size());
   EXPECT_EQ("Subscription 1",
             directive_handler->added_directives()[0].subscription_id());
   EXPECT_EQ("Subscription 2",
             directive_handler->added_directives()[1].subscription_id());
 }
 
 }  // namespace copresence