[Clank] Load origin id before create MediaDrmBridge

media/base/android/media_drm_bridge.h

 // Copyright (c) 2013 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 MEDIA_BASE_ANDROID_MEDIA_DRM_BRIDGE_H_
 #define MEDIA_BASE_ANDROID_MEDIA_DRM_BRIDGE_H_
 
 #include <jni.h>
 #include <stdint.h>
 
@@ skipping 49 matching lines @@
 
   using ResetCredentialsCB = base::Callback<void(bool)>;
 
   // Notification called when MediaCrypto object is ready.
   // Parameters:
   // |media_crypto| - global reference to MediaCrypto object
   // |needs_protected_surface| - true if protected surface is required.
   using MediaCryptoReadyCB = base::Callback<void(JavaObjectPtr media_crypto,
                                                  bool needs_protected_surface)>;
 
+  using CreatedCB = base::OnceCallback<void(scoped_refptr<MediaDrmBridge>)>;
+
   // Checks whether MediaDRM is available and usable, including for decoding.
   // All other static methods check IsAvailable() or equivalent internally.
   // There is no need to check IsAvailable() explicitly before calling them.
   static bool IsAvailable();
 
   static bool RegisterMediaDrmBridge(JNIEnv* env);
 
   // Checks whether |key_system| is supported.
   static bool IsKeySystemSupported(const std::string& key_system);
 
   // Checks whether |key_system| is supported with |container_mime_type|.
   // |container_mime_type| must not be empty.
   static bool IsKeySystemSupportedWithType(
       const std::string& key_system,
       const std::string& container_mime_type);
 
   static bool IsPersistentLicenseTypeSupported(const std::string& key_system);
 
   // Returns the list of the platform-supported key system names that
   // are not handled by Chrome explicitly.
   static std::vector<std::string> GetPlatformKeySystemNames();
 
   // Returns a MediaDrmBridge instance if |key_system| and |security_level| are
   // supported, and nullptr otherwise. The default security level will be used
   // if |security_level| is SECURITY_LEVEL_DEFAULT.
-  static scoped_refptr<MediaDrmBridge> Create(
+  static void Create(
       const std::string& key_system,
       const GURL& security_origin,
       SecurityLevel security_level,
       const CreateFetcherCB& create_fetcher_cb,
       const CreateStorageCB& create_storage_cb,
       const SessionMessageCB& session_message_cb,
       const SessionClosedCB& session_closed_cb,
       const SessionKeysChangeCB& session_keys_change_cb,
-      const SessionExpirationUpdateCB& session_expiration_update_cb);
+      const SessionExpirationUpdateCB& session_expiration_update_cb,
+      CreatedCB created_cb);
 
   // Same as Create() except that no session callbacks are provided. This is
   // used when we need to use MediaDrmBridge without creating any sessions.
   // TODO(yucliu): Pass |security_origin| here to clear per-origin certs and
   // licenses.
-  static scoped_refptr<MediaDrmBridge> CreateWithoutSessionSupport(
+  static void CreateWithoutSessionSupport(
       const std::string& key_system,
       SecurityLevel security_level,
-      const CreateFetcherCB& create_fetcher_cb);
+      const CreateFetcherCB& create_fetcher_cb,
+      CreatedCB created_cb);
 
   // ContentDecryptionModule implementation.
   void SetServerCertificate(
       const std::vector<uint8_t>& certificate,
       std::unique_ptr<media::SimpleCdmPromise> promise) override;
   void CreateSessionAndGenerateRequest(
       CdmSessionType session_type,
       media::EmeInitDataType init_data_type,
       const std::vector<uint8_t>& init_data,
       std::unique_ptr<media::NewSessionCdmPromise> promise) override;
@@ skipping 114 matching lines @@
   // Called by the java object when credential reset is completed.
   void OnResetDeviceCredentialsCompleted(
       JNIEnv* env,
       const base::android::JavaParamRef<jobject>&,
       bool success);
 
  private:
   // For DeleteSoon() in DeleteOnCorrectThread().
   friend class base::DeleteHelper<MediaDrmBridge>;
 
-  static scoped_refptr<MediaDrmBridge> CreateInternal(
-      const std::string& key_system,
-      const GURL& security_origin,
+  static void CreateInternal(
+      const std::vector<uint8_t>& scheme_uuid,
       SecurityLevel security_level,
+      std::unique_ptr<MediaDrmStorageBridge> storage,
       const CreateFetcherCB& create_fetcher_cb,
-      const CreateStorageCB& create_storage_cb,
       const SessionMessageCB& session_message_cb,
       const SessionClosedCB& session_closed_cb,
       const SessionKeysChangeCB& session_keys_change_cb,
-      const SessionExpirationUpdateCB& session_expiration_update_cb);
+      const SessionExpirationUpdateCB& session_expiration_update_cb,
+      CreatedCB bound_cdm_created_cb);
 
   // Constructs a MediaDrmBridge for |scheme_uuid| and |security_level|. The
   // default security level will be used if |security_level| is
   // SECURITY_LEVEL_DEFAULT. Sessions should not be created if session callbacks
   // are null.
   MediaDrmBridge(const std::vector<uint8_t>& scheme_uuid,
-                 const GURL& security_origin,
                  SecurityLevel security_level,
+                 std::unique_ptr<MediaDrmStorageBridge> storage,
                  const CreateFetcherCB& create_fetcher_cb,
-                 const CreateStorageCB& create_storage_cb,
                  const SessionMessageCB& session_message_cb,
                  const SessionClosedCB& session_closed_cb,
                  const SessionKeysChangeCB& session_keys_change_cb,
                  const SessionExpirationUpdateCB& session_expiration_update_cb);
 
   ~MediaDrmBridge() override;
 
   static bool IsSecureDecoderRequired(SecurityLevel security_level);
 
   // Get the security level of the media.
   SecurityLevel GetSecurityLevel();
 
   // A helper method that is called when MediaCrypto is ready.
   void NotifyMediaCryptoReady(JavaObjectPtr j_media_crypto);
 
   // Sends HTTP provisioning request to a provisioning server.
   void SendProvisioningRequest(const std::string& default_url,
                                const std::string& request_data);
 
   // Process the data received by provisioning server.
   void ProcessProvisionResponse(bool success, const std::string& response);
 
   // Called on the |task_runner_| when there is additional usable key.
   void OnHasAdditionalUsableKey();
 
   // UUID of the key system.
   std::vector<uint8_t> scheme_uuid_;
 
-  // Persistent storage for session ID map.
-  MediaDrmStorageBridge storage_;
+  // Persistent storage for session ID map. It may or may not be bound to an
+  // origin.
+  std::unique_ptr<MediaDrmStorageBridge> storage_;
 
   // Java MediaDrm instance.
   base::android::ScopedJavaGlobalRef<jobject> j_media_drm_;
 
   // Java MediaCrypto instance. Possible values are:
   // !j_media_crypto_:
   //   MediaCrypto creation has not been notified via NotifyMediaCryptoReady().
   // !j_media_crypto_->is_null():
   //   MediaCrypto creation succeeded and it has been notified.
   // j_media_crypto_->is_null():
@@ skipping 28 matching lines @@
 
   // NOTE: Weak pointers must be invalidated before all other member variables.
   base::WeakPtrFactory<MediaDrmBridge> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaDrmBridge);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_ANDROID_MEDIA_DRM_BRIDGE_H_