Undoing revert, cl is not the cause of gcm crash on canary.

components/copresence/rpc/rpc_handler.h

 // 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.
 
 #ifndef COMPONENTS_COPRESENCE_RPC_RPC_HANDLER_H_
 #define COMPONENTS_COPRESENCE_RPC_RPC_HANDLER_H_
 
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/callback_forward.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "components/copresence/proto/enums.pb.h"
 #include "components/copresence/public/copresence_delegate.h"
 #include "components/copresence/timed_map.h"
 
 namespace copresence {
 
 struct AudioToken;
 class CopresenceDelegate;
 class DirectiveHandler;
+class GCMHandler;
 class HttpPost;
 class ReportRequest;
 class RequestHeader;
 class SubscribedMessage;
 
 // This class currently handles all communication with the copresence server.
 class RpcHandler {
  public:
   // A callback to indicate whether handler initialization succeeded.
   typedef base::Callback<void(bool)> SuccessCallback;
@@ skipping 23 matching lines @@
                               const PostCleanupCallback&)> PostCallback;
 
   // Report rpc name to send to Apiary.
   static const char kReportRequestRpcName[];
 
   // Constructor. |delegate| and |directive_handler|
   // are owned by the caller and must outlive the RpcHandler.
   // |server_post_callback| should be set only by tests.
   RpcHandler(CopresenceDelegate* delegate,
              DirectiveHandler* directive_handler,
+             GCMHandler* gcm_handler,
              const PostCallback& server_post_callback = PostCallback());
 
   virtual ~RpcHandler();
 
   // Send a ReportRequest from a specific app, and get notified of completion.
   void SendReportRequest(scoped_ptr<ReportRequest> request,
                          const std::string& app_id,
                          const std::string& auth_token,
                          const StatusCallback& callback);
 
@@ skipping 22 matching lines @@
   // which is tied to the auth token (or lack thereof) used to call Report.
   void RegisterForToken(const std::string& auth_token);
 
   // Device registration has completed. Send the requests that it was blocking.
   void ProcessQueuedRequests(const std::string& auth_token);
 
   // Send a ReportRequest from Chrome itself, i.e. no app id.
   void SendReportRequest(scoped_ptr<ReportRequest> request,
                          const std::string& auth_token);
 
+  // Store a GCM ID and send it to the server if needed.
+  void RegisterGcmId(const std::string& gcm_id);
+
   // Server call response handlers.
   void RegisterResponseHandler(const std::string& auth_token,
+                               bool gcm_pending,
                                HttpPost* completed_post,
                                int http_status_code,
                                const std::string& response_data);
   void ReportResponseHandler(const StatusCallback& status_callback,
                              HttpPost* completed_post,
                              int http_status_code,
                              const std::string& response_data);
 
   // If the request has any unpublish or unsubscribe operations, it removes
   // them from our directive handlers.
@@ skipping 23 matching lines @@
   // Wrapper for the http post constructor. This is the default way
   // to contact the server, but it can be overridden for testing.
   void SendHttpPost(net::URLRequestContextGetter* url_context_getter,
                     const std::string& rpc_name,
                     const std::string& api_key,
                     const std::string& auth_token,
                     scoped_ptr<google::protobuf::MessageLite> request_proto,
                     const PostCleanupCallback& callback);
 
   // These belong to the caller.
-  CopresenceDelegate* delegate_;
-  DirectiveHandler* directive_handler_;
+  CopresenceDelegate* const delegate_;
+  DirectiveHandler* const directive_handler_;
+  GCMHandler* const gcm_handler_;
 
   PostCallback server_post_callback_;
 
   ScopedVector<PendingRequest> pending_requests_queue_;
   TimedMap<std::string, bool> invalid_audio_token_cache_;
   std::map<std::string, std::string> device_id_by_auth_token_;
   std::set<HttpPost*> pending_posts_;
+  std::string gcm_id_;
 
   DISALLOW_COPY_AND_ASSIGN(RpcHandler);
 };
 
 }  // namespace copresence
 
 #endif  // COMPONENTS_COPRESENCE_RPC_RPC_HANDLER_H_