BrowserCdmManager: Do not pass MIME types as init_data_type.

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/command_line.h"
@@ skipping 327 matching lines @@
   scoped_ptr<NewSessionPromise> promise(
       new NewSessionPromise(this, render_frame_id, cdm_id, promise_id));
 
   if (init_data.size() > kMaxInitDataLength) {
     LOG(WARNING) << "InitData for ID: " << cdm_id
                  << " too long: " << init_data.size();
     promise->reject(MediaKeys::INVALID_ACCESS_ERROR, 0, "Init data too long.");
     return;
   }
 
-  // Convert the session content type into a MIME type. "audio" and "video"
-  // don't matter, so using "video" for the MIME type.
-  // Ref:
-  // https://dvcs.w3.org/hg/html-media/raw-file/default/encrypted-media/encrypted-media.html#dom-createsession
-  std::string mime_type;
+  media::EmeInitDataType eme_init_data_type = media::EME_INIT_DATA_TYPE_NONE;
   switch (init_data_type) {
-    case CREATE_SESSION_TYPE_WEBM:
-      mime_type = "video/webm";
+    case INIT_DATA_TYPE_WEBM:
+      eme_init_data_type = media::EME_INIT_DATA_TYPE_WEBM;
       break;
-    case CREATE_SESSION_TYPE_MP4:
-      mime_type = "video/mp4";
+#if defined(USE_PROPRIETARY_CODECS)
+    case INIT_DATA_TYPE_CENC:
+      eme_init_data_type = media::EME_INIT_DATA_TYPE_CENC;
       break;
+#endif
     default:
       NOTREACHED();
       promise->reject(MediaKeys::INVALID_ACCESS_ERROR, 0,
                       "Invalid init data type.");
       return;
   }
 
 #if defined(OS_ANDROID)
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableInfobarForProtectedMediaIdentifier)) {
-    GenerateRequestIfPermitted(render_frame_id, cdm_id, mime_type, init_data,
-                               promise.Pass(), true);
+    GenerateRequestIfPermitted(render_frame_id, cdm_id, eme_init_data_type,
+                               init_data, promise.Pass(), true);
     return;
   }
 #endif
 
   BrowserCdm* cdm = GetCdm(render_frame_id, cdm_id);
   if (!cdm) {
     DLOG(WARNING) << "No CDM found for: " << render_frame_id << ", " << cdm_id;
     promise->reject(MediaKeys::INVALID_STATE_ERROR, 0, "CDM not found.");
     return;
   }
 
   std::map<uint64, GURL>::const_iterator iter =
       cdm_security_origin_map_.find(GetId(render_frame_id, cdm_id));
   if (iter == cdm_security_origin_map_.end()) {
     NOTREACHED();
     promise->reject(MediaKeys::INVALID_STATE_ERROR, 0, "CDM not found.");
     return;
   }
   GURL security_origin = iter->second;
 
-  RequestSessionPermission(render_frame_id, security_origin, cdm_id, mime_type,
-                           init_data, promise.Pass());
+  RequestSessionPermission(render_frame_id, security_origin, cdm_id,
+                           eme_init_data_type, init_data, promise.Pass());
 }
 
 void BrowserCdmManager::OnUpdateSession(int render_frame_id,
                                         int cdm_id,
                                         uint32_t promise_id,
                                         const std::string& session_id,
                                         const std::vector<uint8>& response) {
   scoped_ptr<SimplePromise> promise(
       new SimplePromise(this, render_frame_id, cdm_id, promise_id));
 
@@ skipping 90 matching lines @@
   if (cdm_cancel_permission_map_.count(id)) {
     cdm_cancel_permission_map_[id].Run();
     cdm_cancel_permission_map_.erase(id);
   }
 }
 
 void BrowserCdmManager::RequestSessionPermission(
     int render_frame_id,
     const GURL& security_origin,
     int cdm_id,
-    const std::string& init_data_type,
+    media::EmeInitDataType init_data_type,
     const std::vector<uint8>& init_data,
     scoped_ptr<media::NewSessionCdmPromise> promise) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&BrowserCdmManager::RequestSessionPermission, this,
                    render_frame_id, security_origin, cdm_id, init_data_type,
                    init_data, base::Passed(&promise)));
     return;
   }
 
   RenderFrameHost* rfh =
       RenderFrameHost::FromID(render_process_id_, render_frame_id);
   WebContents* web_contents = WebContents::FromRenderFrameHost(rfh);
   DCHECK(web_contents);
   GetContentClient()->browser()->RequestPermission(
       content::PERMISSION_PROTECTED_MEDIA_IDENTIFIER, web_contents,
       0,  // bridge id
       security_origin,
       // Only implemented for Android infobars which do not support
       // user gestures.
       true, base::Bind(&BrowserCdmManager::GenerateRequestIfPermitted, this,
                        render_frame_id, cdm_id, init_data_type, init_data,
                        base::Passed(&promise)));
 }
 
 void BrowserCdmManager::GenerateRequestIfPermitted(
     int render_frame_id,
     int cdm_id,
-    const std::string& init_data_type,
+    media::EmeInitDataType init_data_type,
     const std::vector<uint8>& init_data,
     scoped_ptr<media::NewSessionCdmPromise> promise,
     bool permitted) {
   cdm_cancel_permission_map_.erase(GetId(render_frame_id, cdm_id));
   if (!permitted) {
     promise->reject(MediaKeys::NOT_SUPPORTED_ERROR, 0, "Permission denied.");
     return;
   }
 
   BrowserCdm* cdm = GetCdm(render_frame_id, cdm_id);
   if (!cdm) {
     promise->reject(MediaKeys::INVALID_STATE_ERROR, 0, "CDM not found.");
     return;
   }
 
+  // TODO(ddorwin): Move this conversion to MediaDrmBridge when fixing
+  // crbug.com/417440.
+  // "audio"/"video" does not matter, so use "video".
+  std::string init_data_type_string;
+  switch (init_data_type) {
+    case media::EME_INIT_DATA_TYPE_WEBM:
+      init_data_type_string = "video/webm";
+      break;
+#if defined(USE_PROPRIETARY_CODECS)
+    case media::EME_INIT_DATA_TYPE_CENC:
+      init_data_type_string = "video/mp4";
+      break;
+#endif
+    default:
+      NOTREACHED();
+  }
+
   // 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[0],
+                                       init_data_type_string, &init_data[0],
                                        init_data.size(), promise.Pass());
 }
 
 }  // namespace content