Extract GCMClient data types into separate gcm_types.h

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/command_line.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
@@ skipping 218 matching lines @@
   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,
                                   const std::string& registration_id,
-                                  GCMClient::Result result) OVERRIDE;
+                                  Result result) OVERRIDE;
   virtual void OnUnregisterFinished(const std::string& app_id,
-                                    GCMClient::Result result) OVERRIDE;
+                                    Result result) OVERRIDE;
   virtual void OnSendFinished(const std::string& app_id,
                               const std::string& message_id,
-                              GCMClient::Result result) OVERRIDE {}
+                              Result result) OVERRIDE {}
   virtual void OnMessageReceived(const std::string& registration_id,
-                                 const GCMClient::IncomingMessage& message)
+                                 const IncomingMessage& message)
       OVERRIDE;
   virtual void OnMessagesDeleted(const std::string& app_id) OVERRIDE;
   virtual void OnMessageSendError(
       const std::string& app_id,
-      const gcm::GCMClient::SendErrorDetails& send_error_details) OVERRIDE;
+      const gcm::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();
   }
 
   void reset_last_event() {
     last_event_ = NONE;
     last_app_id_.clear();
     last_registration_id_.clear();
     last_message_id_.clear();
-    last_result_ = GCMClient::UNKNOWN_ERROR;
+    last_result_ = RESULT_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 {
+  Result last_result() const { return last_result_; }
+  const IncomingMessage& last_message() const {
     return last_message_;
   }
-  const GCMClient::SendErrorDetails& last_error_details() const {
+  const SendErrorDetails& last_error_details() const {
     return last_error_details_;
   }
 
   const GServicesSettings& gservices_settings() const {
     return gcm_client_->gservices_settings_;
   }
 
   int64 CurrentTime();
 
   // Tooling.
   void PumpLoop();
   void PumpLoopUntilIdle();
   void QuitLoop();
   void InitializeLoop();
   bool CreateUniqueTempDir();
   AutoAdvancingTestClock* clock() const {
     return reinterpret_cast<AutoAdvancingTestClock*>(gcm_client_->clock_.get());
   }
 
  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_;
+  Result last_result_;
+  IncomingMessage last_message_;
+  SendErrorDetails last_error_details_;
 
   scoped_ptr<GCMClientImpl> gcm_client_;
 
   base::MessageLoop message_loop_;
   scoped_ptr<base::RunLoop> run_loop_;
   net::TestURLFetcherFactory url_fetcher_factory_;
 
   // Injected to GCM client:
   base::ScopedTempDir temp_directory_;
   scoped_refptr<net::TestURLRequestContextGetter> url_request_context_getter_;
 };
 
 GCMClientImplTest::GCMClientImplTest()
     : last_event_(NONE),
-      last_result_(GCMClient::UNKNOWN_ERROR),
+      last_result_(RESULT_UNKNOWN_ERROR),
       url_request_context_getter_(new net::TestURLRequestContextGetter(
           message_loop_.message_loop_proxy())) {
 }
 
 GCMClientImplTest::~GCMClientImplTest() {}
 
 void GCMClientImplTest::SetUp() {
   testing::Test::SetUp();
 #if defined(OS_MACOSX)
   base::CommandLine::ForCurrentProcess()->AppendSwitch(
@@ skipping 131 matching lines @@
   gcm_client_->OnMessageReceivedFromMCS(message);
 }
 
 void GCMClientImplTest::OnGCMReady() {
   last_event_ = LOADING_COMPLETED;
   QuitLoop();
 }
 
 void GCMClientImplTest::OnMessageReceived(
     const std::string& registration_id,
-    const GCMClient::IncomingMessage& message) {
+    const IncomingMessage& message) {
   last_event_ = MESSAGE_RECEIVED;
   last_app_id_ = registration_id;
   last_message_ = message;
   QuitLoop();
 }
 
 void GCMClientImplTest::OnRegisterFinished(const std::string& app_id,
                                            const std::string& registration_id,
-                                           GCMClient::Result result) {
+                                           Result result) {
   last_event_ = REGISTRATION_COMPLETED;
   last_app_id_ = app_id;
   last_registration_id_ = registration_id;
   last_result_ = result;
 }
 
 void GCMClientImplTest::OnUnregisterFinished(const std::string& app_id,
-                                             GCMClient::Result result) {
+                                             Result result) {
   last_event_ = UNREGISTRATION_COMPLETED;
   last_app_id_ = app_id;
   last_result_ = result;
 }
 
 void GCMClientImplTest::OnMessagesDeleted(const std::string& app_id) {
   last_event_ = MESSAGES_DELETED;
   last_app_id_ = app_id;
 }
 
 void GCMClientImplTest::OnMessageSendError(
     const std::string& app_id,
-    const gcm::GCMClient::SendErrorDetails& send_error_details) {
+    const gcm::SendErrorDetails& send_error_details) {
   last_event_ = MESSAGE_SEND_ERROR;
   last_app_id_ = app_id;
   last_error_details_ = send_error_details;
 }
 
 int64 GCMClientImplTest::CurrentTime() {
   return clock()->Now().ToInternalValue() / base::Time::kMicrosecondsPerSecond;
 }
 
 TEST_F(GCMClientImplTest, LoadingCompleted) {
@@ skipping 14 matching lines @@
   EXPECT_FALSE(ExistsRegistration(kAppId));
 
   std::vector<std::string> senders;
   senders.push_back("sender");
   gcm_client()->Register(kAppId, senders);
   CompleteRegistration("reg_id");
 
   EXPECT_EQ(REGISTRATION_COMPLETED, last_event());
   EXPECT_EQ(kAppId, last_app_id());
   EXPECT_EQ("reg_id", last_registration_id());
-  EXPECT_EQ(GCMClient::SUCCESS, last_result());
+  EXPECT_EQ(RESULT_SUCCESS, last_result());
   EXPECT_TRUE(ExistsRegistration(kAppId));
 }
 
 TEST_F(GCMClientImplTest, DISABLED_RegisterAppFromCache) {
   EXPECT_FALSE(ExistsRegistration(kAppId));
 
   std::vector<std::string> senders;
   senders.push_back("sender");
   gcm_client()->Register(kAppId, senders);
   CompleteRegistration("reg_id");
   EXPECT_TRUE(ExistsRegistration(kAppId));
 
   EXPECT_EQ(kAppId, last_app_id());
   EXPECT_EQ("reg_id", last_registration_id());
-  EXPECT_EQ(GCMClient::SUCCESS, last_result());
+  EXPECT_EQ(RESULT_SUCCESS, last_result());
   EXPECT_EQ(REGISTRATION_COMPLETED, last_event());
 
   // Recreate GCMClient in order to load from the persistent store.
   BuildGCMClient(base::TimeDelta());
   InitializeGCMClient();
 
   EXPECT_TRUE(ExistsRegistration(kAppId));
 }
 
 TEST_F(GCMClientImplTest, UnregisterApp) {
   EXPECT_FALSE(ExistsRegistration(kAppId));
 
   std::vector<std::string> senders;
   senders.push_back("sender");
   gcm_client()->Register(kAppId, senders);
   CompleteRegistration("reg_id");
   EXPECT_TRUE(ExistsRegistration(kAppId));
 
   gcm_client()->Unregister(kAppId);
   CompleteUnregistration(kAppId);
 
   EXPECT_EQ(UNREGISTRATION_COMPLETED, last_event());
   EXPECT_EQ(kAppId, last_app_id());
-  EXPECT_EQ(GCMClient::SUCCESS, last_result());
+  EXPECT_EQ(RESULT_SUCCESS, last_result());
   EXPECT_FALSE(ExistsRegistration(kAppId));
 }
 
 TEST_F(GCMClientImplTest, DispatchDownstreamMessage) {
   // Register to receive messages from kSender and kSender2 only.
   std::vector<std::string> senders;
   senders.push_back(kSender);
   senders.push_back(kSender2);
   AddRegistration(kAppId, senders, "reg_id");
 
@@ skipping 45 matching lines @@
   expected_data["error_details"] = "some details";
   MCSMessage message(BuildDownstreamMessage(
       kSender, kAppId, expected_data));
   EXPECT_TRUE(message.IsValid());
   ReceiveMessageFromMCS(message);
 
   EXPECT_EQ(MESSAGE_SEND_ERROR, last_event());
   EXPECT_EQ(kAppId, last_app_id());
   EXPECT_EQ("007", last_error_details().message_id);
   EXPECT_EQ(1UL, last_error_details().additional_data.size());
-  GCMClient::MessageData::const_iterator iter =
+  MessageData::const_iterator iter =
       last_error_details().additional_data.find("error_details");
   EXPECT_TRUE(iter != last_error_details().additional_data.end());
   EXPECT_EQ("some details", iter->second);
 }
 
 TEST_F(GCMClientImplTest, DispatchDownstreamMessgaesDeleted) {
   std::map<std::string, std::string> expected_data;
   expected_data["message_type"] = "deleted_messages";
   MCSMessage message(BuildDownstreamMessage(
       kSender, kAppId, expected_data));
   EXPECT_TRUE(message.IsValid());
   ReceiveMessageFromMCS(message);
 
   EXPECT_EQ(MESSAGES_DELETED, last_event());
   EXPECT_EQ(kAppId, last_app_id());
 }
 
 TEST_F(GCMClientImplTest, SendMessage) {
   mcs_proto::DataMessageStanza stanza;
   stanza.set_ttl(500);
 
-  GCMClient::OutgoingMessage message;
+  OutgoingMessage message;
   message.id = "007";
   message.time_to_live = 500;
   message.data["key"] = "value";
   gcm_client()->Send(kAppId, kSender, message);
 
   EXPECT_EQ(kDataMessageStanzaTag, mcs_client()->last_message_tag());
   EXPECT_EQ(kAppId, mcs_client()->last_data_message_stanza().category());
   EXPECT_EQ(kSender, mcs_client()->last_data_message_stanza().to());
   EXPECT_EQ(500, mcs_client()->last_data_message_stanza().ttl());
   EXPECT_EQ(CurrentTime(), mcs_client()->last_data_message_stanza().sent());
@@ skipping 89 matching lines @@
             gservices_settings().checkin_interval());
   EXPECT_EQ(GURL("http://alternative.url/checkin"),
             gservices_settings().checkin_url());
   EXPECT_EQ(GURL("http://alternative.url/registration"),
             gservices_settings().registration_url());
   EXPECT_EQ("http://alternative.gcm.host", gservices_settings().mcs_hostname());
   EXPECT_EQ(443, gservices_settings().mcs_secure_port());
 }
 
 }  // namespace gcm