Add support to GCMKeyStore for multiple keys per app_id

components/gcm_driver/crypto/gcm_encryption_provider.cc

Index: components/gcm_driver/crypto/gcm_encryption_provider.cc
diff --git a/components/gcm_driver/crypto/gcm_encryption_provider.cc b/components/gcm_driver/crypto/gcm_encryption_provider.cc
index a89fedfb3b09817bd044178ed41380343484fdaf..87df533ee713ef0dc12b7466a53d6f76cd452fe6 100644
--- a/components/gcm_driver/crypto/gcm_encryption_provider.cc
+++ b/components/gcm_driver/crypto/gcm_encryption_provider.cc
@@ -77,18 +77,22 @@ void GCMEncryptionProvider::Init(
 
 void GCMEncryptionProvider::GetEncryptionInfo(
     const std::string& app_id,
+    const std::string& instance_id_authorized_entity,
     const EncryptionInfoCallback& callback) {
   DCHECK(key_store_);
-  key_store_->GetKeys(
-      app_id, base::Bind(&GCMEncryptionProvider::DidGetEncryptionInfo,
-                         weak_ptr_factory_.GetWeakPtr(), app_id, callback));
+  key_store_->GetKeys(app_id, instance_id_authorized_entity,
+                      false /* fallback_to_empty_authorized_entity */,
+                      base::Bind(&GCMEncryptionProvider::DidGetEncryptionInfo,
+                                 weak_ptr_factory_.GetWeakPtr(), app_id,
+                                 instance_id_authorized_entity, callback));
 }
 
 void GCMEncryptionProvider::RemoveEncryptionInfo(
     const std::string& app_id,
+    const std::string& instance_id_authorized_entity,
     const base::Closure& callback) {
   DCHECK(key_store_);
-  key_store_->RemoveKeys(app_id, callback);
+  key_store_->RemoveKeys(app_id, instance_id_authorized_entity, callback);
 }
 
 bool GCMEncryptionProvider::IsEncryptedMessage(const IncomingMessage& message)
@@ -155,23 +159,31 @@ void GCMEncryptionProvider::DecryptMessage(
     return;
   }
 
-  key_store_->GetKeys(
-      app_id, base::Bind(&GCMEncryptionProvider::DecryptMessageWithKey,
-                         weak_ptr_factory_.GetWeakPtr(), message,
-                         callback, encryption_header_values[0].salt,
-                         crypto_key_header_values[0].dh,
-                         encryption_header_values[0].rs));
+  // At this point we don't know whether this message is for an InstanceID token
+  // (key store owner = app_id + ',' + sender_id) or a legacy GCM registration

[Peter Beverloo, 2016/05/09 14:10:09]

Mentioning the key store owner and its format has no added value here; also
please try to avoid mentioning "we". What about:

  // The message that is to be decrypted could be associated with either a v3
  // or v4 (InstanceID) registration, which store encryption keys differently,
  // but the used version is not known at this point.

[johnme, 2016/05/09 18:15:54]

I changed this to: "
  // Use |fallback_to_empty_authorized_entity|, since this message might have
  // been sent to either an InstanceID token or a non-InstanceID registration."

+  // (key store owner = app_id). Try the more specific one first; if that fails,
+  // DecryptMessageWithKey will fall back to the other.
+  key_store_->GetKeys(app_id,
+                      message.sender_id /* instance_id_authorized_entity */,
+                      true /* fallback_to_empty_authorized_entity */,
+                      base::Bind(&GCMEncryptionProvider::DecryptMessageWithKey,
+                                 weak_ptr_factory_.GetWeakPtr(), message,
+                                 callback, encryption_header_values[0].salt,
+                                 crypto_key_header_values[0].dh,
+                                 encryption_header_values[0].rs));
 }
 
 void GCMEncryptionProvider::DidGetEncryptionInfo(
     const std::string& app_id,
+    const std::string& instance_id_authorized_entity,
     const EncryptionInfoCallback& callback,
     const KeyPair& pair,
     const std::string& auth_secret) {
   if (!pair.IsInitialized()) {
     key_store_->CreateKeys(
-        app_id, base::Bind(&GCMEncryptionProvider::DidCreateEncryptionInfo,
-                           weak_ptr_factory_.GetWeakPtr(), callback));
+        app_id, instance_id_authorized_entity,
+        base::Bind(&GCMEncryptionProvider::DidCreateEncryptionInfo,
+                   weak_ptr_factory_.GetWeakPtr(), callback));
     return;
   }