Extract GCMClient data types into separate gcm_types.h

sync/notifier/gcm_network_channel.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 "base/base64.h"
 #include "base/i18n/time_formatting.h"
 #include "base/metrics/histogram.h"
 #include "base/sha1.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
@@ skipping 107 matching lines @@
   net::NetworkChangeNotifier::RemoveNetworkChangeObserver(this);
 }
 
 void GCMNetworkChannel::Register() {
   delegate_->Register(base::Bind(&GCMNetworkChannel::OnRegisterComplete,
                                  weak_factory_.GetWeakPtr()));
 }
 
 void GCMNetworkChannel::OnRegisterComplete(
     const std::string& registration_id,
-    gcm::GCMClient::Result result) {
+    gcm::Result result) {
   DCHECK(CalledOnValidThread());
-  if (result == gcm::GCMClient::SUCCESS) {
+  if (result == gcm::RESULT_SUCCESS) {
     DCHECK(!registration_id.empty());
     DVLOG(2) << "Got registration_id";
     register_backoff_entry_->Reset();
     registration_id_ = registration_id;
     if (!cached_message_.empty())
       RequestAccessToken();
   } else {
     DVLOG(2) << "Register failed: " << result;
     // Retry in case of transient error.
     switch (result) {
-      case gcm::GCMClient::NETWORK_ERROR:
-      case gcm::GCMClient::SERVER_ERROR:
-      case gcm::GCMClient::TTL_EXCEEDED:
-      case gcm::GCMClient::UNKNOWN_ERROR: {
+      case gcm::RESULT_NETWORK_ERROR:
+      case gcm::RESULT_SERVER_ERROR:
+      case gcm::RESULT_TTL_EXCEEDED:
+      case gcm::RESULT_UNKNOWN_ERROR: {
         register_backoff_entry_->InformOfRequest(false);
         base::MessageLoop::current()->PostDelayedTask(
             FROM_HERE,
             base::Bind(&GCMNetworkChannel::Register,
                        weak_factory_.GetWeakPtr()),
             register_backoff_entry_->GetTimeUntilRelease());
         break;
       }
       default:
         break;
@@ skipping 222 matching lines @@
 void GCMNetworkChannel::ResetRegisterBackoffEntryForTest(
     const net::BackoffEntry::Policy* policy) {
   register_backoff_entry_.reset(new net::BackoffEntry(policy));
 }
 
 GCMNetworkChannelDiagnostic::GCMNetworkChannelDiagnostic(
     GCMNetworkChannel* parent)
     : parent_(parent),
       last_message_empty_echo_token_(false),
       last_post_response_code_(0),
-      registration_result_(gcm::GCMClient::UNKNOWN_ERROR),
+      registration_result_(gcm::RESULT_UNKNOWN_ERROR),
       sent_messages_count_(0) {}
 
 scoped_ptr<base::DictionaryValue>
 GCMNetworkChannelDiagnostic::CollectDebugData() const {
   scoped_ptr<base::DictionaryValue> status(new base::DictionaryValue);
   status->SetString("GCMNetworkChannel.Channel", "GCM");
   std::string reg_id_hash = base::SHA1HashString(registration_id_);
   status->SetString("GCMNetworkChannel.HashedRegistrationID",
                     base::HexEncode(reg_id_hash.c_str(), reg_id_hash.size()));
   status->SetString("GCMNetworkChannel.RegistrationResult",
                     GCMClientResultToString(registration_result_));
   status->SetBoolean("GCMNetworkChannel.HadLastMessageEmptyEchoToken",
                      last_message_empty_echo_token_);
   status->SetString(
       "GCMNetworkChannel.LastMessageReceivedTime",
       base::TimeFormatShortDateAndTime(last_message_received_time_));
   status->SetInteger("GCMNetworkChannel.LastPostResponseCode",
                      last_post_response_code_);
   status->SetInteger("GCMNetworkChannel.SentMessages", sent_messages_count_);
   status->SetInteger("GCMNetworkChannel.ReceivedMessages",
                      parent_->GetReceivedMessagesCount());
   return status.Pass();
 }
 
 std::string GCMNetworkChannelDiagnostic::GCMClientResultToString(
-    const gcm::GCMClient::Result result) const {
+    const gcm::Result result) const {
 #define ENUM_CASE(x) case x: return #x; break;
   switch (result) {
-    ENUM_CASE(gcm::GCMClient::SUCCESS);
-    ENUM_CASE(gcm::GCMClient::NETWORK_ERROR);
-    ENUM_CASE(gcm::GCMClient::SERVER_ERROR);
-    ENUM_CASE(gcm::GCMClient::TTL_EXCEEDED);
-    ENUM_CASE(gcm::GCMClient::UNKNOWN_ERROR);
-    ENUM_CASE(gcm::GCMClient::NOT_SIGNED_IN);
-    ENUM_CASE(gcm::GCMClient::INVALID_PARAMETER);
-    ENUM_CASE(gcm::GCMClient::ASYNC_OPERATION_PENDING);
+    ENUM_CASE(gcm::RESULT_SUCCESS);
+    ENUM_CASE(gcm::RESULT_NETWORK_ERROR);
+    ENUM_CASE(gcm::RESULT_SERVER_ERROR);
+    ENUM_CASE(gcm::RESULT_TTL_EXCEEDED);
+    ENUM_CASE(gcm::RESULT_UNKNOWN_ERROR);
+    ENUM_CASE(gcm::RESULT_NOT_SIGNED_IN);
+    ENUM_CASE(gcm::RESULT_INVALID_PARAMETER);
+    ENUM_CASE(gcm::RESULT_ASYNC_OPERATION_PENDING);
   }
   NOTREACHED();
   return "";
 }
 
 }  // namespace syncer