Support getting and deleting token for Instance ID.

components/gcm_driver/gcm_client.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_GCM_DRIVER_GCM_CLIENT_H_
 #define COMPONENTS_GCM_DRIVER_GCM_CLIENT_H_
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
+#include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_ptr.h"
 #include "components/gcm_driver/gcm_activity.h"
+#include "components/gcm_driver/registration_info.h"
 
 template <class T> class scoped_refptr;
 
 class GURL;
 
 namespace base {
 class FilePath;
 class SequencedTaskRunner;
 class Timer;
 }
@@ skipping 131 matching lines @@
     std::string account_id;
     std::string email;
     std::string access_token;
   };
 
   // A delegate interface that allows the GCMClient instance to interact with
   // its caller, i.e. notifying asynchronous event.
   class Delegate {
    public:
     // Called when the registration completed successfully or an error occurs.
-    // |app_id|: application ID.
+    // |registration_info|: the specific information required for the
+    //                      registration.
     // |registration_id|: non-empty if the registration completed successfully.
     // |result|: the type of the error if an error occured, success otherwise.
-    virtual void OnRegisterFinished(const std::string& app_id,
-                                    const std::string& registration_id,
-                                    Result result) = 0;
+    virtual void OnRegisterFinished(
+        const linked_ptr<RegistrationInfo>& registration_info,
+        const std::string& registration_id,
+        Result result) = 0;
 
     // Called when the unregistration completed.
-    // |app_id|: application ID.
+    // |registration_info|: the specific information required for the
+    //                      registration.
     // |result|: result of the unregistration.
-    virtual void OnUnregisterFinished(const std::string& app_id,
-                                      GCMClient::Result result) = 0;
+    virtual void OnUnregisterFinished(
+        const linked_ptr<RegistrationInfo>& registration_info,
+        GCMClient::Result result) = 0;
 
     // Called when the message is scheduled to send successfully or an error
     // occurs.
     // |app_id|: application ID.
     // |message_id|: ID of the message being sent.
     // |result|: the type of the error if an error occured, success otherwise.
     virtual void OnSendFinished(const std::string& app_id,
                                 const std::string& message_id,
                                 Result result) = 0;
 
@@ skipping 63 matching lines @@
 
   // This will initiate the GCM connection only if |start_mode| means to start
   // the GCM immediately or the GCM registration records are found in the store.
   // Note that it is OK to call Start multiple times and the implementation
   // should handle it gracefully.
   virtual void Start(StartMode start_mode) = 0;
 
   // Stops using the GCM service. This will not erase the persisted data.
   virtual void Stop() = 0;
 
-  // Registers the application for GCM. Delegate::OnRegisterFinished will be
-  // called asynchronously upon completion.
-  // |app_id|: application ID.
-  // |sender_ids|: list of IDs of the servers that are allowed to send the
-  //               messages to the application. These IDs are assigned by the
-  //               Google API Console.
-  virtual void Register(const std::string& app_id,
-                        const std::vector<std::string>& sender_ids) = 0;
+  // Registers with the server to access the provided service.
+  // Delegate::OnRegisterFinished will be called asynchronously upon completion.
+  // |registration_info|: the specific information required for the
+  //                      registration. For GCM, it will contain app id and
+  //                      sender IDs. For InstanceID, it will contain app_id,
+  //                      authorized entity and scope.
+  virtual void Register(
+      const linked_ptr<RegistrationInfo>& registration_info) = 0;
 
-  // Unregisters the application from GCM when it is uninstalled.
+  // Unregisters from the server to stop accessing the provided service.
   // Delegate::OnUnregisterFinished will be called asynchronously upon
   // completion.
-  // |app_id|: application ID.
-  virtual void Unregister(const std::string& app_id) = 0;
+  // |registration_info|: the specific information required for the
+  //                      registration. For GCM, it will contain app id (sender
+  //                      IDs can be ingored). For InstanceID, it will contain
+  //                      app id, authorized entity and scope.
+  virtual void Unregister(
+      const linked_ptr<RegistrationInfo>& registration_info) = 0;
 
   // Sends a message to a given receiver. Delegate::OnSendFinished will be
   // called asynchronously upon completion.
   // |app_id|: application ID.
   // |receiver_id|: registration ID of the receiver party.
   // |message|: message to be sent.
   virtual void Send(const std::string& app_id,
                     const std::string& receiver_id,
                     const OutgoingMessage& message) = 0;
 
@@ skipping 20 matching lines @@
   virtual void RemoveAccountMapping(const std::string& account_id) = 0;
 
   // Sets last token fetch time in persistent store.
   virtual void SetLastTokenFetchTime(const base::Time& time) = 0;
 
   // Updates the timer used by the HeartbeatManager for sending heartbeats.
   virtual void UpdateHeartbeatTimer(scoped_ptr<base::Timer> timer) = 0;
 
   // Adds the Instance ID data for a specific app to the persistent store.
   virtual void AddInstanceIDData(const std::string& app_id,
-                                 const std::string& instance_id_data) = 0;
+                                 const std::string& instance_id,
+                                 const std::string& extra_data) = 0;
 
   // Removes the Instance ID data for a specific app from the persistent store.
   virtual void RemoveInstanceIDData(const std::string& app_id) = 0;
 
   // Retrieves the Instance ID data for a specific app from the persistent
   // store.
-  virtual std::string GetInstanceIDData(const std::string& app_id) = 0;
+  virtual void GetInstanceIDData(const std::string& app_id,
+                                 std::string* instance_id,
+                                 std::string* extra_data) = 0;
 
   // Gets and sets custom heartbeat interval for the MCS connection.
   // |scope| is used to identify the component that requests a custom interval
   // to be set, and allows that component to later revoke the setting. It should
   // be unique.
   virtual void AddHeartbeatInterval(const std::string& scope,
                                     int interval_ms) = 0;
   virtual void RemoveHeartbeatInterval(const std::string& scope) = 0;
 };
 
 }  // namespace gcm
 
 #endif  // COMPONENTS_GCM_DRIVER_GCM_CLIENT_H_