Extract GCMClient data types into separate gcm_types.h

chrome/browser/extensions/api/gcm/gcm_apitest.cc

 // Copyright 2013 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 "base/prefs/pref_service.h"
 #include "base/run_loop.h"
 #include "chrome/browser/extensions/api/gcm/gcm_api.h"
 #include "chrome/browser/extensions/extension_apitest.h"
 #include "chrome/browser/extensions/extension_gcm_app_handler.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/services/gcm/fake_gcm_profile_service.h"
 #include "chrome/browser/services/gcm/gcm_client_factory.h"
 #include "chrome/browser/services/gcm/gcm_profile_service_factory.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/ui_test_utils.h"
 
 namespace {
 
 const char kEventsExtension[] = "gcm/events";
 
-gcm::GCMClient::SendErrorDetails CreateErrorDetails(
+gcm::SendErrorDetails CreateErrorDetails(
     const std::string& message_id,
-    const gcm::GCMClient::Result result,
+    const gcm::Result result,
     const std::string& total_messages) {
-  gcm::GCMClient::SendErrorDetails error;
+  gcm::SendErrorDetails error;
   error.message_id = message_id;
   error.result = result;
   error.additional_data["expectedMessageId"] = message_id;
   switch (result) {
-    case gcm::GCMClient::ASYNC_OPERATION_PENDING:
+    case gcm::RESULT_ASYNC_OPERATION_PENDING:
       error.additional_data["expectedErrorMessage"] =
           "Asynchronous operation is pending.";
       break;
-    case gcm::GCMClient::SERVER_ERROR:
+    case gcm::RESULT_SERVER_ERROR:
       error.additional_data["expectedErrorMessage"] = "Server error occurred.";
       break;
-    case gcm::GCMClient::NETWORK_ERROR:
+    case gcm::RESULT_NETWORK_ERROR:
       error.additional_data["expectedErrorMessage"] = "Network error occurred.";
       break;
-    case gcm::GCMClient::TTL_EXCEEDED:
+    case gcm::RESULT_TTL_EXCEEDED:
       error.additional_data["expectedErrorMessage"] = "Time-to-live exceeded.";
       break;
-    case gcm::GCMClient::UNKNOWN_ERROR:
+    case gcm::RESULT_UNKNOWN_ERROR:
     default:  // Default case is the same as UNKNOWN_ERROR
       error.additional_data["expectedErrorMessage"] = "Unknown error occurred.";
       break;
   }
   error.additional_data["totalMessages"] = total_messages;
   return error;
 }
 
 }  // namespace
 
@@ skipping 70 matching lines @@
 
   const std::vector<std::string>& sender_ids =
       service()->last_registered_sender_ids();
   EXPECT_TRUE(std::find(sender_ids.begin(), sender_ids.end(), "Sender1") !=
                   sender_ids.end());
   EXPECT_TRUE(std::find(sender_ids.begin(), sender_ids.end(), "Sender2") !=
                   sender_ids.end());
 }
 
 IN_PROC_BROWSER_TEST_F(GcmApiTest, Unregister) {
-  service()->AddExpectedUnregisterResponse(gcm::GCMClient::SUCCESS);
-  service()->AddExpectedUnregisterResponse(gcm::GCMClient::SERVER_ERROR);
+  service()->AddExpectedUnregisterResponse(gcm::RESULT_SUCCESS);
+  service()->AddExpectedUnregisterResponse(gcm::RESULT_SERVER_ERROR);
 
   ASSERT_TRUE(RunExtensionTest("gcm/functions/unregister"));
 }
 
 IN_PROC_BROWSER_TEST_F(GcmApiTest, SendValidation) {
   ASSERT_TRUE(RunExtensionTest("gcm/functions/send"));
 }
 
 IN_PROC_BROWSER_TEST_F(GcmApiTest, SendMessageData) {
   StartCollecting();
   ASSERT_TRUE(RunExtensionTest("gcm/functions/send_message_data"));
 
   EXPECT_EQ("destination-id", service()->last_receiver_id());
-  const gcm::GCMClient::OutgoingMessage& message =
+  const gcm::OutgoingMessage& message =
       service()->last_sent_message();
-  gcm::GCMClient::MessageData::const_iterator iter;
+  gcm::MessageData::const_iterator iter;
 
   EXPECT_TRUE((iter = message.data.find("key1")) != message.data.end());
   EXPECT_EQ("value1", iter->second);
 
   EXPECT_TRUE((iter = message.data.find("key2")) != message.data.end());
   EXPECT_EQ("value2", iter->second);
 }
 
 IN_PROC_BROWSER_TEST_F(GcmApiTest, OnMessagesDeleted) {
   ResultCatcher catcher;
@@ skipping 11 matching lines @@
 IN_PROC_BROWSER_TEST_F(GcmApiTest, OnMessage) {
   ResultCatcher catcher;
   catcher.RestrictToProfile(profile());
 
   const extensions::Extension* extension =
       LoadTestExtension(kEventsExtension, "on_message.html");
   ASSERT_TRUE(extension);
 
   extensions::ExtensionGCMAppHandler app_handler(profile());
 
-  gcm::GCMClient::IncomingMessage message;
+  gcm::IncomingMessage message;
   message.data["property1"] = "value1";
   message.data["property2"] = "value2";
   // First message is sent without a collapse key.
   app_handler.OnMessage(extension->id(), message);
 
   // Second message carries the same data and a collapse key.
   message.collapse_key = "collapseKeyValue";
   app_handler.OnMessage(extension->id(), message);
 
   EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
 }
 
 IN_PROC_BROWSER_TEST_F(GcmApiTest, OnSendError) {
   ResultCatcher catcher;
   catcher.RestrictToProfile(profile());
 
   const extensions::Extension* extension =
       LoadTestExtension(kEventsExtension, "on_send_error.html");
   ASSERT_TRUE(extension);
 
   std::string total_expected_messages = "5";
   extensions::ExtensionGCMAppHandler app_handler(profile());
   app_handler.OnSendError(
       extension->id(),
       CreateErrorDetails("error_message_1",
-                         gcm::GCMClient::ASYNC_OPERATION_PENDING,
+                         gcm::RESULT_ASYNC_OPERATION_PENDING,
                          total_expected_messages));
   app_handler.OnSendError(
       extension->id(),
       CreateErrorDetails("error_message_2",
-                         gcm::GCMClient::SERVER_ERROR,
+                         gcm::RESULT_SERVER_ERROR,
                          total_expected_messages));
   app_handler.OnSendError(
       extension->id(),
       CreateErrorDetails("error_message_3",
-                         gcm::GCMClient::NETWORK_ERROR,
+                         gcm::RESULT_NETWORK_ERROR,
                          total_expected_messages));
   app_handler.OnSendError(
       extension->id(),
       CreateErrorDetails("error_message_4",
-                         gcm::GCMClient::UNKNOWN_ERROR,
+                         gcm::RESULT_UNKNOWN_ERROR,
                          total_expected_messages));
   app_handler.OnSendError(
       extension->id(),
       CreateErrorDetails("error_message_5",
-                         gcm::GCMClient::TTL_EXCEEDED,
+                         gcm::RESULT_TTL_EXCEEDED,
                          total_expected_messages));
 
   EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
 }
 
 IN_PROC_BROWSER_TEST_F(GcmApiTest, Incognito) {
   ResultCatcher catcher;
   catcher.RestrictToProfile(profile());
   ResultCatcher incognito_catcher;
   incognito_catcher.RestrictToProfile(profile()->GetOffTheRecordProfile());
 
   ASSERT_TRUE(RunExtensionTestIncognito("gcm/functions/incognito"));
 
   EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
   EXPECT_TRUE(incognito_catcher.GetNextResult()) << incognito_catcher.message();
 }
 
 }  // namespace extensions