Integrate InstanceID with GCM crypto provider

components/gcm_driver/instance_id/instance_id.h

 // Copyright 2015 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_INSTANCE_ID_INSTANCE_ID_H_
 #define COMPONENTS_GCM_DRIVER_INSTANCE_ID_INSTANCE_ID_H_
 
 #include <map>
 #include <memory>
 #include <string>
 
 #include "base/callback.h"
 #include "base/macros.h"
+#include "base/memory/weak_ptr.h"
 #include "base/time/time.h"
 
 namespace gcm {
-class InstanceIDHandler;
+class GCMDriver;
 }  // namespace gcm
 
 namespace instance_id {
 
+// Scope passed to getToken to obtain GCM registration tokens.
+// Must match Java GoogleCloudMessaging.INSTANCE_ID_SCOPE.

[Peter Beverloo, 2016/05/11 16:05:00]

Please document *why* you could pass this to getToken().

[johnme, 2016/05/13 16:25:45]

Done. Also moved comment to .cc file (for consistency with most comments in
Chrome, and because it the "must match" part is best paired with the
definition).

+extern const char kGCMScope[];
+
 // Encapsulates Instance ID functionalities that need to be implemented for
 // different platforms. One instance is created per application. Life of
 // Instance ID is managed by the InstanceIDDriver.
 class InstanceID {
  public:
   enum Result {
     // Successful operation.
     SUCCESS,
     // Invalid parameter.
     INVALID_PARAMETER,
@@ skipping 11 matching lines @@
 
   // Asynchronous callbacks. Must not synchronously delete |this| (using
   // InstanceIDDriver::RemoveInstanceID).
   typedef base::Callback<void(const std::string& app_id,
                               bool update_id)> TokenRefreshCallback;
   typedef base::Callback<void(const std::string& id)> GetIDCallback;
   typedef base::Callback<void(const base::Time& creation_time)>
       GetCreationTimeCallback;
   typedef base::Callback<void(const std::string& token,
                               Result result)> GetTokenCallback;
+  typedef base::Callback<void(const std::string&, const std::string&)>
+      GetEncryptionInfoCallback;
   typedef base::Callback<void(Result result)> DeleteTokenCallback;
   typedef base::Callback<void(Result result)> DeleteIDCallback;
 
   static const int kInstanceIDByteLength = 8;
 
   // Creator.
   // |app_id|: identifies the application that uses the Instance ID.
   // |handler|: provides the GCM functionality needed to support Instance ID.
   //            Must outlive this class. On Android, this can be null instead.
   static std::unique_ptr<InstanceID> Create(const std::string& app_id,
-                                            gcm::InstanceIDHandler* handler);
+                                            gcm::GCMDriver* gcm_driver);
 
   virtual ~InstanceID();
 
   // Sets the callback that will be invoked when the token refresh event needs
   // to be triggered.
   void SetTokenRefreshCallback(const TokenRefreshCallback& callback);
 
   // Returns the Instance ID.
   virtual void GetID(const GetIDCallback& callback) = 0;
 
   // Returns the time when the InstanceID has been generated.
   virtual void GetCreationTime(const GetCreationTimeCallback& callback) = 0;
 
   // Retrieves a token that allows the authorized entity to access the service
   // defined as "scope".
   // |authorized_entity|: identifies the entity that is authorized to access
   //                      resources associated with this Instance ID. It can be
   //                      another Instance ID or a project ID.
   // |scope|: identifies authorized actions that the authorized entity can take.
   //          E.g. for sending GCM messages, "GCM" scope should be used.
   // |options|: allows including a small number of string key/value pairs that
   //            will be associated with the token and may be used in processing
   //            the request.
   // |callback|: to be called once the asynchronous operation is done.
   virtual void GetToken(const std::string& authorized_entity,
                         const std::string& scope,
                         const std::map<std::string, std::string>& options,
                         const GetTokenCallback& callback) = 0;
 
+  // Get the public encryption key and the authentication secret associated with
+  // a GCM-scoped token. If encryption info is not yet associated, it will be
+  // created. The |callback| will be invoked when it is available. Only use with
+  // InstanceID tokens; use GCMDriver::GetEncryptionInfo for GCM registrations.

[Peter Beverloo, 2016/05/11 16:05:00]

This is a non-static method on the InstanceID class, that last sentence seems
fairly self-explanatory to me? How real is the risk that someone would misuse
this?

Also, I'm going to have to ask you to do the reverse of the other CL here
(sorry!)- it's consistent in this file to document methods as:

|param_name|: description

Best to match that.

[johnme, 2016/05/13 16:25:45]

Fair. I'll keep the reverse comment though, since it's more likely that someone
might accidentally use the GCMDriver one for an IID.
Done.

+  void GetEncryptionInfo(const std::string& authorized_entity,
+                         const GetEncryptionInfoCallback& callback);
+
   // Revokes a granted token.
   // |authorized_entity|: the authorized entity that is passed for obtaining a
   //                      token.
   // |scope|: the scope that is passed for obtaining a token.
   // |callback|: to be called once the asynchronous operation is done.
-  virtual void DeleteToken(const std::string& authorized_entity,
-                           const std::string& scope,
-                           const DeleteTokenCallback& callback) = 0;
+  void DeleteToken(const std::string& authorized_entity,
+                   const std::string& scope,
+                   const DeleteTokenCallback& callback);
 
   // Resets the app instance identifier and revokes all tokens associated with
   // it.
   // |callback|: to be called once the asynchronous operation is done.
-  virtual void DeleteID(const DeleteIDCallback& callback) = 0;
+  void DeleteID(const DeleteIDCallback& callback);
 
   std::string app_id() const { return app_id_; }
 
  protected:
-  InstanceID(const std::string& app_id);
+  InstanceID(const std::string& app_id, gcm::GCMDriver* gcm_driver);
+
+  // Platform-specific implementations.
+  virtual void DeleteTokenImpl(const std::string& authorized_entity,
+                               const std::string& scope,
+                               const DeleteTokenCallback& callback) = 0;
+  virtual void DeleteIDImpl(const DeleteIDCallback& callback) = 0;
 
   void NotifyTokenRefresh(bool update_id);
 
+  gcm::GCMDriver* gcm_driver() { return gcm_driver_; }
+
  private:
+  void DidDelete(const std::string& authorized_entity,
+                 const base::Callback<void(Result result)>& callback,
+                 Result result);
+
+  // Owned by GCMProfileServiceFactory, which is a dependency of
+  // InstanceIDProfileServiceFactory, which owns this.
+  gcm::GCMDriver* gcm_driver_;
+
   std::string app_id_;
   TokenRefreshCallback token_refresh_callback_;
 
+  base::WeakPtrFactory<InstanceID> weak_ptr_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(InstanceID);
 };
 
 }  // namespace instance_id
 
 #endif  // COMPONENTS_GCM_DRIVER_INSTANCE_ID_INSTANCE_ID_H_