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

google_apis/gcm/gcm_client_impl_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 "google_apis/gcm/gcm_client_impl.h"
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
-#include "base/strings/string_number_conversions.h"
 #include "base/test/simple_test_clock.h"
 #include "components/os_crypt/os_crypt.h"
 #include "google_apis/gcm/base/mcs_message.h"
 #include "google_apis/gcm/base/mcs_util.h"
 #include "google_apis/gcm/engine/fake_connection_factory.h"
 #include "google_apis/gcm/engine/fake_connection_handler.h"
 #include "google_apis/gcm/protocol/android_checkin.pb.h"
 #include "google_apis/gcm/protocol/checkin.pb.h"
 #include "google_apis/gcm/protocol/mcs.pb.h"
 #include "net/url_request/test_url_fetcher_factory.h"
@@ skipping 10 matching lines @@
   LOADING_COMPLETED,
   REGISTRATION_COMPLETED,
   UNREGISTRATION_COMPLETED,
   MESSAGE_SEND_ERROR,
   MESSAGE_RECEIVED,
   MESSAGES_DELETED,
 };
 
 const uint64 kDeviceAndroidId = 54321;
 const uint64 kDeviceSecurityToken = 12345;
-const int64 kSettingsCheckinInterval = 0;
-const char kSettingsCheckinIntervalKey[] = "checkin_interval";
-const char kSettingsDefaultDigest[] = "default_digest";
 const char kAppId[] = "app_id";
 const char kSender[] = "project_id";
 const char kSender2[] = "project_id2";
 const char kSender3[] = "project_id3";
 const char kRegistrationResponsePrefix[] = "token=";
 const char kUnregistrationResponsePrefix[] = "deleted=";
 
 // Helper for building arbitrary data messages.
 MCSMessage BuildDownstreamMessage(
     const std::string& project_id,
@@ skipping 111 matching lines @@
                           public GCMClient::Delegate {
  public:
   GCMClientImplTest();
   virtual ~GCMClientImplTest();
 
   virtual void SetUp() OVERRIDE;
 
   void BuildGCMClient();
   void InitializeGCMClient();
   void ReceiveMessageFromMCS(const MCSMessage& message);
-  void CompleteCheckin(
-      uint64 android_id,
-      uint64 security_token,
-      const std::string& digest,
-      const std::map<std::string, std::string>& settings);
+  void CompleteCheckin(uint64 android_id, uint64 security_token);
   void CompleteRegistration(const std::string& registration_id);
   void CompleteUnregistration(const std::string& app_id);
 
   bool ExistsRegistration(const std::string& app_id) const;
   void AddRegistration(const std::string& app_id,
                        const std::vector<std::string>& sender_ids,
                        const std::string& registration_id);
 
   // GCMClient::Delegate overrides (for verification).
   virtual void OnRegisterFinished(const std::string& app_id,
@@ skipping 13 matching lines @@
       const gcm::GCMClient::SendErrorDetails& send_error_details) OVERRIDE;
   virtual void OnGCMReady() OVERRIDE;
 
   GCMClientImpl* gcm_client() const { return gcm_client_.get(); }
   FakeMCSClient* mcs_client() const {
     return reinterpret_cast<FakeMCSClient*>(gcm_client_->mcs_client_.get());
   }
   ConnectionFactory* connection_factory() const {
     return gcm_client_->connection_factory_.get();
   }
-  GServicesSettingsMap& services_settings() {
-    return gcm_client_->gservices_settings_;
-  }
-  const std::string& services_digest() {
-    return gcm_client_->gservices_digest_;
-  }
 
   void reset_last_event() {
     last_event_ = NONE;
     last_app_id_.clear();
     last_registration_id_.clear();
     last_message_id_.clear();
     last_result_ = GCMClient::UNKNOWN_ERROR;
   }
 
   LastEvent last_event() const { return last_event_; }
   const std::string& last_app_id() const { return last_app_id_; }
   const std::string& last_registration_id() const {
     return last_registration_id_;
   }
   const std::string& last_message_id() const { return last_message_id_; }
   GCMClient::Result last_result() const { return last_result_; }
   const GCMClient::IncomingMessage& last_message() const {
     return last_message_;
   }
   const GCMClient::SendErrorDetails& last_error_details() const {
     return last_error_details_;
   }
+
+  int64 CurrentTime();
+
+ private:
+  // Tooling.
+  void PumpLoop();
+  void PumpLoopUntilIdle();
+  void QuitLoop();
+
   base::SimpleTestClock* clock() const {
     return reinterpret_cast<base::SimpleTestClock*>(gcm_client_->clock_.get());
   }
 
-  int64 CurrentTime();
-
-  // Tooling.
-  void PumpLoop();
-  void PumpLoopUntilIdle();
-  void QuitLoop();
-  void ResetLoop();
-
-  bool CreateUniqueTempDir();
-
- private:
   // Variables used for verification.
   LastEvent last_event_;
   std::string last_app_id_;
   std::string last_registration_id_;
   std::string last_message_id_;
   GCMClient::Result last_result_;
   GCMClient::IncomingMessage last_message_;
   GCMClient::SendErrorDetails last_error_details_;
 
   scoped_ptr<GCMClientImpl> gcm_client_;
@@ skipping 10 matching lines @@
 GCMClientImplTest::GCMClientImplTest()
     : last_event_(NONE),
       last_result_(GCMClient::UNKNOWN_ERROR),
       url_request_context_getter_(new net::TestURLRequestContextGetter(
           message_loop_.message_loop_proxy())) {
 }
 
 GCMClientImplTest::~GCMClientImplTest() {}
 
 void GCMClientImplTest::SetUp() {
-  ASSERT_TRUE(CreateUniqueTempDir());
-  ResetLoop();
+  ASSERT_TRUE(temp_directory_.CreateUniqueTempDir());
+  run_loop_.reset(new base::RunLoop);
   BuildGCMClient();
   InitializeGCMClient();
-  CompleteCheckin(kDeviceAndroidId,
-                  kDeviceSecurityToken,
-                  kSettingsDefaultDigest,
-                  std::map<std::string, std::string>());
+  CompleteCheckin(kDeviceAndroidId, kDeviceSecurityToken);
 }
 
 void GCMClientImplTest::PumpLoop() {
   run_loop_->Run();
   run_loop_.reset(new base::RunLoop());
 }
 
 void GCMClientImplTest::PumpLoopUntilIdle() {
   run_loop_->RunUntilIdle();
   run_loop_.reset(new base::RunLoop());
 }
 
 void GCMClientImplTest::QuitLoop() {
   if (run_loop_ && run_loop_->running())
     run_loop_->Quit();
 }
 
-void GCMClientImplTest::ResetLoop() {
-  run_loop_.reset(new base::RunLoop);
-}
-
-bool GCMClientImplTest::CreateUniqueTempDir() {
-  return temp_directory_.CreateUniqueTempDir();
-}
-
 void GCMClientImplTest::BuildGCMClient() {
   gcm_client_.reset(new GCMClientImpl(
       make_scoped_ptr<GCMInternalsBuilder>(new FakeGCMInternalsBuilder())));
 }
 
-void GCMClientImplTest::CompleteCheckin(
-    uint64 android_id,
-    uint64 security_token,
-    const std::string& digest,
-    const std::map<std::string, std::string>& settings) {
+void GCMClientImplTest::CompleteCheckin(uint64 android_id,
+                                        uint64 security_token) {
   checkin_proto::AndroidCheckinResponse response;
   response.set_stats_ok(true);
   response.set_android_id(android_id);
   response.set_security_token(security_token);
 
-  // For testing GServices settings.
-  response.set_digest(digest);
-  for (std::map<std::string, std::string>::const_iterator it = settings.begin();
-       it != settings.end(); ++it) {
-    checkin_proto::GservicesSetting* setting = response.add_setting();
-    setting->set_name(it->first);
-    setting->set_value(it->second);
-  }
-
   std::string response_string;
   response.SerializeToString(&response_string);
 
   net::TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
   fetcher->set_response_code(net::HTTP_OK);
   fetcher->SetResponseString(response_string);
   fetcher->delegate()->OnURLFetchComplete(fetcher);
   url_fetcher_factory_.RemoveFetcherFromMap(0);
 }
@@ skipping 274 matching lines @@
   EXPECT_EQ(500, mcs_client()->last_data_message_stanza().ttl());
   EXPECT_EQ(CurrentTime(), mcs_client()->last_data_message_stanza().sent());
   EXPECT_EQ("007", mcs_client()->last_data_message_stanza().id());
   EXPECT_EQ("gcm@chrome.com", mcs_client()->last_data_message_stanza().from());
   EXPECT_EQ(kSender, mcs_client()->last_data_message_stanza().to());
   EXPECT_EQ("key", mcs_client()->last_data_message_stanza().app_data(0).key());
   EXPECT_EQ("value",
             mcs_client()->last_data_message_stanza().app_data(0).value());
 }
 
-class GCMClientImplCheckinTest : public GCMClientImplTest {
- public:
-  GCMClientImplCheckinTest();
-  virtual ~GCMClientImplCheckinTest();
-
-  virtual void SetUp() OVERRIDE;
-
-  std::map<std::string, std::string> GenerateSettings();
-};
-
-GCMClientImplCheckinTest::GCMClientImplCheckinTest() {}
-
-GCMClientImplCheckinTest::~GCMClientImplCheckinTest() {}
-
-void GCMClientImplCheckinTest::SetUp() {
-  ASSERT_TRUE(CreateUniqueTempDir());
-  ResetLoop();
-  BuildGCMClient();
-  InitializeGCMClient();
-}
-
-std::map<std::string, std::string>
-GCMClientImplCheckinTest::GenerateSettings() {
-  std::map<std::string, std::string> settings;
-  settings[kSettingsCheckinIntervalKey] =
-      base::Int64ToString(kSettingsCheckinInterval);
-  return settings;
-}
-
-TEST_F(GCMClientImplCheckinTest, GServicesSettingsAfterInitialCheckin) {
-  CompleteCheckin(kDeviceAndroidId, kDeviceSecurityToken,
-      kSettingsDefaultDigest, GenerateSettings());
-  EXPECT_EQ(base::Int64ToString(kSettingsCheckinInterval),
-            services_settings()[kSettingsCheckinIntervalKey]);
-}
-
-// This test only checks that periodic checkin happens.
-TEST_F(GCMClientImplCheckinTest, PeriodicCheckin) {
-  std::map<std::string, std::string> settings = GenerateSettings();
-  CompleteCheckin(kDeviceAndroidId, kDeviceSecurityToken,
-      kSettingsDefaultDigest, settings);
-  PumpLoopUntilIdle();
-
-  CompleteCheckin(kDeviceAndroidId, kDeviceSecurityToken,
-      kSettingsDefaultDigest, settings);
-  }
-
-// This test checks that checkin reponse with the same digest will not update
-// G-services settings.
-TEST_F(GCMClientImplCheckinTest, GServicesSettingsSameDigest) {
-  std::map<std::string, std::string> settings = GenerateSettings();
-  settings["checkin_url"] = "http://checkin.google.com";
-  CompleteCheckin(kDeviceAndroidId, kDeviceSecurityToken,
-      kSettingsDefaultDigest, settings);
-  EXPECT_EQ(settings, services_settings());
-  EXPECT_EQ(kSettingsDefaultDigest, services_digest());
-  PumpLoopUntilIdle();
-
-  // Response will carry same digest and no settings.
-  CompleteCheckin(kDeviceAndroidId, kDeviceSecurityToken,
-      kSettingsDefaultDigest, std::map<std::string, std::string>());
-  EXPECT_EQ(settings, services_settings());
-  EXPECT_EQ(kSettingsDefaultDigest, services_digest());
-}
-
-// Test that checkin response with a different digest will also update the
-// G-services settings.
-TEST_F(GCMClientImplCheckinTest, GServicesSettingsDifferentDigest) {
-  std::map<std::string, std::string> settings = GenerateSettings();
-  settings["checkin_url"] = "http://checkin.google.com";
-  CompleteCheckin(kDeviceAndroidId, kDeviceSecurityToken,
-      kSettingsDefaultDigest, settings);
-  EXPECT_EQ(settings, services_settings());
-  EXPECT_EQ(kSettingsDefaultDigest, services_digest());
-  PumpLoopUntilIdle();
-
-  settings.clear();
-  settings["some_settings"] = "on second checkin";
-  settings[kSettingsCheckinIntervalKey] = "2100";
-  settings["checkin_url"] = "http://checkin.google.com";
-  std::string new_digest = "some_other_digest";
-
-  CompleteCheckin(kDeviceAndroidId, kDeviceSecurityToken, new_digest, settings);
-  EXPECT_EQ(settings, services_settings());
-  EXPECT_EQ(new_digest, services_digest());
-}
-
 }  // namespace gcm