Revert of Plumb |use_secure_codecs| through to BrowserCdmFactoryAndroid.

content/browser/media/cdm/browser_cdm_manager.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 "content/browser/media/cdm/browser_cdm_manager.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/task_runner.h"
+#include "content/common/media/cdm_messages.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/permission_manager.h"
 #include "content/public/browser/permission_type.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "media/base/browser_cdm.h"
@@ skipping 258 matching lines @@
 
 void BrowserCdmManager::OnSessionExpirationUpdate(
     int render_frame_id,
     int cdm_id,
     const std::string& session_id,
     const base::Time& new_expiry_time) {
   Send(new CdmMsg_SessionExpirationUpdate(render_frame_id, cdm_id, session_id,
                                           new_expiry_time));
 }
 
-void BrowserCdmManager::OnInitializeCdm(
-    int render_frame_id,
-    int cdm_id,
-    uint32_t promise_id,
-    const CdmHostMsg_InitializeCdm_Params& params) {
-  if (params.key_system.size() > media::limits::kMaxKeySystemLength) {
-    NOTREACHED() << "Invalid key system: " << params.key_system;
+void BrowserCdmManager::OnInitializeCdm(int render_frame_id,
+                                        int cdm_id,
+                                        uint32_t promise_id,
+                                        const std::string& key_system,
+                                        const GURL& security_origin) {
+  if (key_system.size() > media::limits::kMaxKeySystemLength) {
+    NOTREACHED() << "Invalid key system: " << key_system;
     RejectPromise(render_frame_id, cdm_id, promise_id,
                   MediaKeys::INVALID_ACCESS_ERROR, 0, "Invalid key system.");
     return;
   }
 
-  AddCdm(render_frame_id, cdm_id, promise_id, params.key_system,
-         params.security_origin, params.use_hw_secure_codecs);
+  AddCdm(render_frame_id, cdm_id, promise_id, key_system, security_origin);
 }
 
 void BrowserCdmManager::OnSetServerCertificate(
     int render_frame_id,
     int cdm_id,
     uint32_t promise_id,
     const std::vector<uint8_t>& certificate) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   scoped_ptr<SimplePromise> promise(
@@ skipping 118 matching lines @@
 
 // Use a weak pointer here instead of |this| to avoid circular references.
 #define BROWSER_CDM_MANAGER_CB(func)                                   \
   base::Bind(&BrowserCdmManager::func, weak_ptr_factory_.GetWeakPtr(), \
              render_frame_id, cdm_id)
 
 void BrowserCdmManager::AddCdm(int render_frame_id,
                                int cdm_id,
                                uint32_t promise_id,
                                const std::string& key_system,
-                               const GURL& security_origin,
-                               bool use_hw_secure_codecs) {
+                               const GURL& security_origin) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
   DCHECK(!GetCdm(render_frame_id, cdm_id));
 
+  bool use_secure_surface = false;
   scoped_ptr<SimplePromise> promise(
       new SimplePromise(this, render_frame_id, cdm_id, promise_id));
 
+#if defined(OS_ANDROID)
+  // TODO(sandersd): Pass the security level from key system instead.
+  // http://crbug.com/467779
+  RenderFrameHost* rfh =
+      RenderFrameHost::FromID(render_process_id_, render_frame_id);
+  WebContents* web_contents = WebContents::FromRenderFrameHost(rfh);
+  if (web_contents) {
+    content::RendererPreferences* prefs =
+        web_contents->GetMutableRendererPrefs();
+    use_secure_surface = prefs->use_video_overlay_for_embedded_encrypted_video;
+  }
+#endif
+
   scoped_ptr<BrowserCdm> cdm(media::CreateBrowserCdm(
-      key_system, use_hw_secure_codecs,
-      BROWSER_CDM_MANAGER_CB(OnSessionMessage),
+      key_system, use_secure_surface, BROWSER_CDM_MANAGER_CB(OnSessionMessage),
       BROWSER_CDM_MANAGER_CB(OnSessionClosed),
       BROWSER_CDM_MANAGER_CB(OnLegacySessionError),
       BROWSER_CDM_MANAGER_CB(OnSessionKeysChange),
       BROWSER_CDM_MANAGER_CB(OnSessionExpirationUpdate)));
 
   if (!cdm) {
     DVLOG(1) << "failed to create CDM.";
     promise->reject(MediaKeys::INVALID_STATE_ERROR, 0, "Failed to create CDM.");
     return;
   }
@@ skipping 102 matching lines @@
   }
 
   // Only the temporary session type is supported in browser CDM path.
   // TODO(xhwang): Add SessionType support if needed.
   cdm->CreateSessionAndGenerateRequest(media::MediaKeys::TEMPORARY_SESSION,
                                        init_data_type, init_data,
                                        promise.Pass());
 }
 
 }  // namespace content