Extract GCMClient data types into separate gcm_types.h

chrome/browser/invalidation/gcm_invalidation_bridge.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/bind.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "chrome/browser/invalidation/gcm_invalidation_bridge.h"
 #include "chrome/browser/services/gcm/gcm_service.h"
@@ skipping 37 matching lines @@
   virtual void InvalidateToken(const std::string& token) OVERRIDE;
   virtual void Register(RegisterCallback callback) OVERRIDE;
   virtual void SetMessageReceiver(MessageCallback callback) OVERRIDE;
 
   void RequestTokenFinished(RequestTokenCallback callback,
                             const GoogleServiceAuthError& error,
                             const std::string& token);
 
   void RegisterFinished(RegisterCallback callback,
                         const std::string& registration_id,
-                        gcm::GCMClient::Result result);
+                        gcm::Result result);
 
   void OnIncomingMessage(const std::string& message,
                          const std::string& echo_token);
 
  private:
   base::WeakPtr<GCMInvalidationBridge> bridge_;
   scoped_refptr<base::SingleThreadTaskRunner> ui_thread_task_runner_;
 
   MessageCallback message_callback_;
 
@@ skipping 59 matching lines @@
     RequestTokenCallback callback,
     const GoogleServiceAuthError& error,
     const std::string& token) {
   DCHECK(CalledOnValidThread());
   callback.Run(error, token);
 }
 
 void GCMInvalidationBridge::Core::RegisterFinished(
     RegisterCallback callback,
     const std::string& registration_id,
-    gcm::GCMClient::Result result) {
+    gcm::Result result) {
   DCHECK(CalledOnValidThread());
   callback.Run(registration_id, result);
 }
 
 void GCMInvalidationBridge::Core::OnIncomingMessage(
     const std::string& message,
     const std::string& echo_token) {
   DCHECK(!message_callback_.is_null());
   message_callback_.Run(message, echo_token);
 }
@@ skipping 103 matching lines @@
   gcm_service_->Register(kInvalidationsAppId,
                          sender_ids,
                          base::Bind(&GCMInvalidationBridge::RegisterFinished,
                                     weak_factory_.GetWeakPtr(),
                                     callback));
 }
 
 void GCMInvalidationBridge::RegisterFinished(
     syncer::GCMNetworkChannelDelegate::RegisterCallback callback,
     const std::string& registration_id,
-    gcm::GCMClient::Result result) {
+    gcm::Result result) {
   DCHECK(CalledOnValidThread());
   core_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&GCMInvalidationBridge::Core::RegisterFinished,
                  core_,
                  callback,
                  registration_id,
                  result));
 }
 
 void GCMInvalidationBridge::SubscribeForIncomingMessages() {
   // No-op if GCMClient is disabled.
   if (gcm_service_ == NULL)
     return;
 
   DCHECK(!subscribed_for_incoming_messages_);
   gcm_service_->AddAppHandler(kInvalidationsAppId, this);
   subscribed_for_incoming_messages_ = true;
 }
 
 void GCMInvalidationBridge::ShutdownHandler() {
   // Nothing to do.
 }
 
 void GCMInvalidationBridge::OnMessage(
     const std::string& app_id,
-    const gcm::GCMClient::IncomingMessage& message) {
-  gcm::GCMClient::MessageData::const_iterator it;
+    const gcm::IncomingMessage& message) {
+  gcm::MessageData::const_iterator it;
   std::string content;
   std::string echo_token;
   it = message.data.find(kContentKey);
   if (it != message.data.end())
     content = it->second;
   it = message.data.find(kEchoTokenKey);
   if (it != message.data.end())
     echo_token = it->second;
 
   core_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&GCMInvalidationBridge::Core::OnIncomingMessage,
                  core_,
                  content,
                  echo_token));
 }
 
 void GCMInvalidationBridge::OnMessagesDeleted(const std::string& app_id) {
   // Cacheinvalidation doesn't use long lived non-collapsable messages with GCM.
   // Android implementation of cacheinvalidation doesn't handle MessagesDeleted
   // callback so this should be no-op in desktop version as well.
 }
 
 void GCMInvalidationBridge::OnSendError(
     const std::string& app_id,
-    const gcm::GCMClient::SendErrorDetails& send_error_details) {
+    const gcm::SendErrorDetails& send_error_details) {
   // cacheinvalidation doesn't send messages over GCM.
   NOTREACHED();
 }
 
 }  // namespace invalidation