media: Add DefaultMediaPermission.

content/renderer/render_frame_impl.cc

 // Copyright 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.
 
 #include "content/renderer/render_frame_impl.h"
 
 #include <map>
 #include <string>
 
 #include "base/auto_reset.h"
@@ skipping 1893 matching lines @@
     render_view_->RegisterVideoHoleFrame(this);
     contains_media_player_ = true;
   }
 #endif  // defined(VIDEO_HOLE)
 
   blink::WebMediaStream web_stream(
       blink::WebMediaStreamRegistry::lookupMediaStreamDescriptor(url));
   if (!web_stream.isNull())
     return CreateWebMediaPlayerForMediaStream(url, client);
 
+  if (!media_permission_dispatcher_)
+    media_permission_dispatcher_ = new MediaPermissionDispatcher(this);
+
 #if defined(OS_ANDROID)
-  return CreateAndroidWebMediaPlayer(url, client, initial_cdm);
+  return CreateAndroidWebMediaPlayer(url, client, media_permission_dispatcher_,
+                                     initial_cdm);
 #else
   scoped_refptr<media::MediaLog> media_log(new RenderMediaLog());
 
+
   RenderThreadImpl* render_thread = RenderThreadImpl::current();
   media::WebMediaPlayerParams params(
       base::Bind(&ContentRendererClient::DeferMediaLoad,
                  base::Unretained(GetContentClient()->renderer()),
                  static_cast<RenderFrame*>(this)),
       render_thread->GetAudioRendererMixerManager()->CreateInput(
           render_view_->routing_id_, routing_id_),
       media_log, render_thread->GetMediaThreadTaskRunner(),
       render_thread->compositor_message_loop_proxy(),
-      base::Bind(&GetSharedMainThreadContext3D), initial_cdm);
+      base::Bind(&GetSharedMainThreadContext3D), media_permission_dispatcher_,
+      initial_cdm);
 
 #if defined(ENABLE_PEPPER_CDMS)
   scoped_ptr<media::CdmFactory> cdm_factory(
       new RenderCdmFactory(base::Bind(&PepperCdmWrapperImpl::Create, frame)));
 #elif defined(ENABLE_BROWSER_CDMS)
   scoped_ptr<media::CdmFactory> cdm_factory(
       new RenderCdmFactory(GetCdmManager()));
 #else
   scoped_ptr<media::CdmFactory> cdm_factory(new RenderCdmFactory());
 #endif
@@ skipping 1468 matching lines @@
 #if defined(ENABLE_PEPPER_CDMS)
     scoped_ptr<media::CdmFactory> cdm_factory(
         new RenderCdmFactory(base::Bind(PepperCdmWrapperImpl::Create, frame_)));
 #elif defined(ENABLE_BROWSER_CDMS)
     scoped_ptr<media::CdmFactory> cdm_factory(
         new RenderCdmFactory(GetCdmManager()));
 #else
     scoped_ptr<media::CdmFactory> cdm_factory(new RenderCdmFactory());
 #endif
 
-    DCHECK(!media_permission_dispatcher_);
-    media_permission_dispatcher_ = new MediaPermissionDispatcher(this);
+    if (!media_permission_dispatcher_)
+      media_permission_dispatcher_ = new MediaPermissionDispatcher(this);
 
     web_encrypted_media_client_.reset(new media::WebEncryptedMediaClientImpl(
         cdm_factory.Pass(), media_permission_dispatcher_));
   }
   return web_encrypted_media_client_.get();
 }
 
 blink::WebMIDIClient* RenderFrameImpl::webMIDIClient() {
   if (!midi_dispatcher_)
     midi_dispatcher_ = new MidiDispatcher(this);
@@ skipping 985 matching lines @@
 
   const WebURLRequest& request = ds->request();
   return request.url();
 }
 
 #if defined(OS_ANDROID)
 
 WebMediaPlayer* RenderFrameImpl::CreateAndroidWebMediaPlayer(
     const blink::WebURL& url,
     WebMediaPlayerClient* client,
+    media::MediaPermission* media_permission,
     blink::WebContentDecryptionModule* initial_cdm) {
   GpuChannelHost* gpu_channel_host =
       RenderThreadImpl::current()->EstablishGpuChannelSync(
           CAUSE_FOR_GPU_LAUNCH_VIDEODECODEACCELERATOR_INITIALIZE);
   if (!gpu_channel_host) {
     LOG(ERROR) << "Failed to establish GPU channel for media player";
     return NULL;
   }
 
   scoped_refptr<StreamTextureFactory> stream_texture_factory;
@@ skipping 12 matching lines @@
     stream_texture_factory = StreamTextureFactoryImpl::Create(
         context_provider, gpu_channel_host, routing_id_);
   }
 
   return new WebMediaPlayerAndroid(
       frame_,
       client,
       weak_factory_.GetWeakPtr(),
       GetMediaPlayerManager(),
       GetCdmManager(),
+      media_permission,
       initial_cdm,
       stream_texture_factory,
       RenderThreadImpl::current()->GetMediaThreadTaskRunner(),
       new RenderMediaLog());
 }
 
 RendererMediaPlayerManager* RenderFrameImpl::GetMediaPlayerManager() {
   if (!media_player_manager_)
     media_player_manager_ = new RendererMediaPlayerManager(this);
   return media_player_manager_;
 }
 
 #endif  // defined(OS_ANDROID)
 
 #if defined(ENABLE_BROWSER_CDMS)
 RendererCdmManager* RenderFrameImpl::GetCdmManager() {
   if (!cdm_manager_)
     cdm_manager_ = new RendererCdmManager(this);
   return cdm_manager_;
 }
 #endif  // defined(ENABLE_BROWSER_CDMS)
 
 }  // namespace content