Revert of [GCM] Adding periodic checkin controlled by G-services settings

google_apis/gcm/engine/checkin_request_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 <string>
 #include <vector>
 
 #include "google_apis/gcm/engine/checkin_request.h"
 #include "google_apis/gcm/protocol/checkin.pb.h"
 #include "net/base/backoff_entry.h"
@@ skipping 33 matching lines @@
   false,
 };
 
 }
 
 const uint64 kAndroidId = 42UL;
 const uint64 kBlankAndroidId = 999999UL;
 const uint64 kBlankSecurityToken = 999999UL;
 const char kChromeVersion[] = "Version String";
 const uint64 kSecurityToken = 77;
-const char kSettingsDigest[] = "settings_digest";
 
 class CheckinRequestTest : public testing::Test {
  public:
   enum ResponseScenario {
     VALID_RESPONSE,  // Both android_id and security_token set in response.
     MISSING_ANDROID_ID,  // android_id is missing.
     MISSING_SECURITY_TOKEN,  // security_token is missing.
     ANDROID_ID_IS_ZER0,  // android_id is 0.
     SECURITY_TOKEN_IS_ZERO  // security_token is 0.
   };
 
   CheckinRequestTest();
   virtual ~CheckinRequestTest();
 
-  void FetcherCallback(
-      const checkin_proto::AndroidCheckinResponse& response);
+  void FetcherCallback(uint64 android_id, uint64 security_token);
 
   void CreateRequest(uint64 android_id, uint64 security_token);
 
   void SetResponseStatusAndString(
       net::HttpStatusCode status_code,
       const std::string& response_data);
 
   void CompleteFetch();
 
   void SetResponse(ResponseScenario response_scenario);
@@ skipping 16 matching lines @@
       android_id_(kBlankAndroidId),
       security_token_(kBlankSecurityToken),
       checkin_device_type_(0),
       url_request_context_getter_(new net::TestURLRequestContextGetter(
           message_loop_.message_loop_proxy())) {
   account_ids_.push_back("account_id");
 }
 
 CheckinRequestTest::~CheckinRequestTest() {}
 
-void CheckinRequestTest::FetcherCallback(
-    const checkin_proto::AndroidCheckinResponse& checkin_response) {
+void CheckinRequestTest::FetcherCallback(uint64 android_id,
+                                         uint64 security_token) {
   callback_called_ = true;
-  if (checkin_response.has_android_id())
-    android_id_ = checkin_response.android_id();
-  if (checkin_response.has_security_token())
-    security_token_ = checkin_response.security_token();
+  android_id_ = android_id;
+  security_token_ = security_token;
 }
 
 void CheckinRequestTest::CreateRequest(uint64 android_id,
                                        uint64 security_token) {
   // First setup a chrome_build protobuf.
   chrome_build_proto_.set_platform(
       checkin_proto::ChromeBuildProto::PLATFORM_LINUX);
   chrome_build_proto_.set_channel(
       checkin_proto::ChromeBuildProto::CHANNEL_CANARY);
   chrome_build_proto_.set_chrome_version(kChromeVersion);
-
-  CheckinRequest::RequestInfo request_info(
-      android_id,
-      security_token,
-      kSettingsDigest,
-      account_ids_,
-      chrome_build_proto_);
   // Then create a request with that protobuf and specified android_id,
   // security_token.
   request_.reset(new CheckinRequest(
-      request_info,
+      base::Bind(&CheckinRequestTest::FetcherCallback, base::Unretained(this)),
       kDefaultBackoffPolicy,
-      base::Bind(&CheckinRequestTest::FetcherCallback, base::Unretained(this)),
+      chrome_build_proto_,
+      android_id,
+      security_token,
+      account_ids_,
       url_request_context_getter_.get()));
 
   // Setting android_id_ and security_token_ to blank value, not used elsewhere
   // in the tests.
   callback_called_ = false;
   android_id_ = kBlankAndroidId;
   security_token_ = kBlankSecurityToken;
 }
 
 void CheckinRequestTest::SetResponseStatusAndString(
@@ skipping 52 matching lines @@
   EXPECT_EQ(chrome_build_proto_.channel(),
             request_proto.checkin().chrome_build().channel());
 
 #if defined(CHROME_OS)
   EXPECT_EQ(checkin_proto::DEVICE_CHROME_OS, request_proto.checkin().type());
 #else
   EXPECT_EQ(checkin_proto::DEVICE_CHROME_BROWSER,
             request_proto.checkin().type());
 #endif
 
-  EXPECT_EQ(kSettingsDigest, request_proto.digest());
   EXPECT_EQ(1, request_proto.account_cookie_size());
   EXPECT_EQ("[account_id]", request_proto.account_cookie(0));
 }
 
 TEST_F(CheckinRequestTest, ResponseBodyEmpty) {
   CreateRequest(0u, 0u);
   request_->Start();
 
   SetResponseStatusAndString(net::HTTP_OK, std::string());
   CompleteFetch();
@@ skipping 26 matching lines @@
 }
 
 TEST_F(CheckinRequestTest, ResponseHttpStatusUnauthorized) {
   CreateRequest(0u, 0u);
   request_->Start();
 
   SetResponseStatusAndString(net::HTTP_UNAUTHORIZED, std::string());
   CompleteFetch();
 
   EXPECT_TRUE(callback_called_);
-  EXPECT_EQ(kBlankAndroidId, android_id_);
-  EXPECT_EQ(kBlankSecurityToken, security_token_);
+  EXPECT_EQ(0u, android_id_);
+  EXPECT_EQ(0u, security_token_);
 }
 
 TEST_F(CheckinRequestTest, ResponseHttpStatusBadRequest) {
   CreateRequest(0u, 0u);
   request_->Start();
 
   SetResponseStatusAndString(net::HTTP_BAD_REQUEST, std::string());
   CompleteFetch();
 
   EXPECT_TRUE(callback_called_);
-  EXPECT_EQ(kBlankAndroidId, android_id_);
-  EXPECT_EQ(kBlankSecurityToken, security_token_);
+  EXPECT_EQ(0u, android_id_);
+  EXPECT_EQ(0u, security_token_);
 }
 
 TEST_F(CheckinRequestTest, ResponseHttpStatusNotOK) {
   CreateRequest(0u, 0u);
   request_->Start();
 
   SetResponseStatusAndString(net::HTTP_INTERNAL_SERVER_ERROR, std::string());
   CompleteFetch();
 
   EXPECT_FALSE(callback_called_);
@@ skipping 92 matching lines @@
 
   SetResponse(VALID_RESPONSE);
   CompleteFetch();
 
   EXPECT_TRUE(callback_called_);
   EXPECT_EQ(kAndroidId, android_id_);
   EXPECT_EQ(kSecurityToken, security_token_);
 }
 
 }  // namespace gcm