media: Simplify MediaPermissionDispatcher.

content/renderer/media/webrtc/peer_connection_dependency_factory.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/renderer/media/webrtc/peer_connection_dependency_factory.h"
 
 #include <stddef.h>
 
 #include <utility>
 #include <vector>
@@ skipping 378 matching lines @@
 
   // Copy the flag from Preference associated with this WebFrame.
   P2PPortAllocator::Config port_config;
 
   // |media_permission| will be called to check mic/camera permission. If at
   // least one of them is granted, P2PPortAllocator is allowed to gather local
   // host IP addresses as ICE candidates. |media_permission| could be nullptr,
   // which means the permission will be granted automatically. This could be the
   // case when either the experiment is not enabled or the preference is not
   // enforced.
-  scoped_ptr<media::MediaPermission> media_permission;
+  //
+  // Note on |media_permission| lifetime: |media_permission| is owned by a frame
+  // (RenderFrameImpl). It is also stored as an indirect member of
+  // RTCPeerConnectionHandler (through PeerConnection/PeerConnectionInterface ->
+  // P2PPortAllocator -> FilteringNetworkManager -> |media_permission|).
+  // The RTCPeerConnectionHandler is owned as RTCPeerConnection::m_peerHandler
+  // in Blink, which will be reset in RTCPeerConnection::stop(). Since
+  // ActiveDOMObject::stop() is guaranteed to be called before a frame is
+  // detached, it is impossible for RTCPeerConnectionHandler to outlive the
+  // frame. Therefore using a raw pointer of |media_permission| is safe here.

[xhwang, 2016/01/29 01:08:06]

guoweis: Could you please test this tear down logic to make sure the theory is
correct? Thanks!

+  media::MediaPermission* media_permission = nullptr;
   if (!GetContentClient()
            ->renderer()
            ->ShouldEnforceWebRTCRoutingPreferences()) {
     port_config.enable_multiple_routes = true;
     port_config.enable_nonproxied_udp = true;
     VLOG(3) << "WebRTC routing preferences will not be enforced";
   } else {
     if (web_frame && web_frame->view()) {
       RenderViewImpl* renderer_view_impl =
           RenderViewImpl::FromWebView(web_frame->view());
@@ skipping 36 matching lines @@
           base::CommandLine::ForCurrentProcess()->HasSwitch(
               switches::kEnforceWebRtcIPPermissionCheck);
       create_media_permission =
           create_media_permission ||
           StartsWith(base::FieldTrialList::FindFullName(
                          "WebRTC-LocalIPPermissionCheck"),
                      "Enabled", base::CompareCase::SENSITIVE);
       if (create_media_permission) {
         content::RenderFrameImpl* render_frame =
             content::RenderFrameImpl::FromWebFrame(web_frame);
-        if (render_frame) {
-          media_permission = render_frame->CreateMediaPermissionProxy(
-              chrome_worker_thread_.task_runner());
-        }
+        if (render_frame)
+          media_permission = render_frame->GetMediaPermission();
         DCHECK(media_permission);
       }
     }
   }
 
   const GURL& requesting_origin =
       GURL(web_frame->document().url()).GetOrigin();
 
   scoped_ptr<rtc::NetworkManager> network_manager;
   if (port_config.enable_multiple_routes) {
-    media::MediaPermission* media_permission_ptr = media_permission.get();
     FilteringNetworkManager* filtering_network_manager =
         new FilteringNetworkManager(network_manager_, requesting_origin,
-                                    std::move(media_permission));
-    if (media_permission_ptr) {
+                                    media_permission);
+    if (media_permission) {
       // Start permission check earlier to reduce any impact to call set up
       // time. It's safe to use Unretained here since both destructor and
       // Initialize can only be called on the worker thread.
       chrome_worker_thread_.task_runner()->PostTask(
           FROM_HERE, base::Bind(&FilteringNetworkManager::Initialize,
                                 base::Unretained(filtering_network_manager)));
     }
     network_manager.reset(filtering_network_manager);
   } else {
     network_manager.reset(new EmptyNetworkManager(network_manager_));
@@ skipping 289 matching lines @@
 }
 
 void PeerConnectionDependencyFactory::EnsureWebRtcAudioDeviceImpl() {
   if (audio_device_.get())
     return;
 
   audio_device_ = new WebRtcAudioDeviceImpl();
 }
 
 }  // namespace content