Move MediaDrmBridge provision communication to native side.

media/base/android/media_drm_bridge_unittest.cc

 // 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.
 
 #include "base/android/build_info.h"
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "media/base/android/media_drm_bridge.h"
+#include "media/base/android/provision_fetcher.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #include "widevine_cdm_version.h"  // In SHARED_INTERMEDIATE_DIR.
 
 namespace media {
 
 #define EXPECT_TRUE_IF_WIDEVINE_AVAILABLE(a)                              \
   do {                                                                    \
     if (!MediaDrmBridge::IsKeySystemSupported(kWidevineKeySystem)) {      \
       VLOG(0) << "Widevine not supported on device.";                     \
@@ skipping 15 matching lines @@
 
 // Helper functions to avoid typing "MediaDrmBridge::" in tests.
 
 static bool IsKeySystemSupportedWithType(
     const std::string& key_system,
     const std::string& container_mime_type) {
   return MediaDrmBridge::IsKeySystemSupportedWithType(key_system,
                                                       container_mime_type);
 }
 
+namespace {
+// Mock ProvisionFetcher.
+class MockProvisionFetcher : public ProvisionFetcher {
+ public:
+  void Retrieve(const std::string& default_url,
+                const std::string& request_data,
+                const ResponseCB& response_cb) override {}
+
+  static scoped_ptr<ProvisionFetcher> Create() {
+    return scoped_ptr<ProvisionFetcher>(new MockProvisionFetcher);
+  }
+};
+
+}  // namespace (anonymous)
+
 TEST(MediaDrmBridgeTest, IsKeySystemSupported_Widevine) {
   // TODO(xhwang): Enable when b/13564917 is fixed.
   // EXPECT_TRUE_IF_AVAILABLE(
   //     IsKeySystemSupportedWithType(kWidevineKeySystem, kAudioMp4));
   EXPECT_TRUE_IF_WIDEVINE_AVAILABLE(
       IsKeySystemSupportedWithType(kWidevineKeySystem, kVideoMp4));
 
   if (base::android::BuildInfo::GetInstance()->sdk_int() <= 19) {
     EXPECT_FALSE(IsKeySystemSupportedWithType(kWidevineKeySystem, kAudioWebM));
     EXPECT_FALSE(IsKeySystemSupportedWithType(kWidevineKeySystem, kVideoWebM));
@@ skipping 16 matching lines @@
   EXPECT_FALSE(IsKeySystemSupportedWithType(kInvalidKeySystem, kVideoMp4));
   EXPECT_FALSE(IsKeySystemSupportedWithType(kInvalidKeySystem, kAudioWebM));
   EXPECT_FALSE(IsKeySystemSupportedWithType(kInvalidKeySystem, kVideoWebM));
   EXPECT_FALSE(IsKeySystemSupportedWithType(kInvalidKeySystem, "unknown"));
   EXPECT_FALSE(IsKeySystemSupportedWithType(kInvalidKeySystem, "video/avi"));
   EXPECT_FALSE(IsKeySystemSupportedWithType(kInvalidKeySystem, "audio/mp3"));
 }
 
 TEST(MediaDrmBridgeTest, CreateWithoutSessionSupport_Widevine) {
   base::MessageLoop message_loop_;
-  EXPECT_TRUE_IF_WIDEVINE_AVAILABLE(
-      MediaDrmBridge::CreateWithoutSessionSupport(kWidevineKeySystem));
+  EXPECT_TRUE_IF_WIDEVINE_AVAILABLE(MediaDrmBridge::CreateWithoutSessionSupport(
+      kWidevineKeySystem, MockProvisionFetcher::Create().Pass()));
 }
 
 // Invalid key system is NOT supported regardless whether MediaDrm is available.
 TEST(MediaDrmBridgeTest, CreateWithoutSessionSupport_InvalidKeySystem) {
   base::MessageLoop message_loop_;
-  EXPECT_FALSE(MediaDrmBridge::CreateWithoutSessionSupport(kInvalidKeySystem));
+  EXPECT_FALSE(MediaDrmBridge::CreateWithoutSessionSupport(
+      kInvalidKeySystem, MockProvisionFetcher::Create().Pass()));
 }
 
 TEST(MediaDrmBridgeTest, SetSecurityLevel_Widevine) {
   base::MessageLoop message_loop_;
   scoped_refptr<MediaDrmBridge> media_drm_bridge =
-      MediaDrmBridge::CreateWithoutSessionSupport(kWidevineKeySystem);
+      MediaDrmBridge::CreateWithoutSessionSupport(
+          kWidevineKeySystem, MockProvisionFetcher::Create().Pass());
   EXPECT_TRUE_IF_WIDEVINE_AVAILABLE(media_drm_bridge);
   if (!media_drm_bridge)
     return;
 
   EXPECT_FALSE(media_drm_bridge->SetSecurityLevel(kLNone));
   // We test "L3" fully. But for "L1" we don't check the result as it depends on
   // whether the test device supports "L1".
   EXPECT_TRUE(media_drm_bridge->SetSecurityLevel(kL3));
   media_drm_bridge->SetSecurityLevel(kL1);
 }
 
 }  // namespace media