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 <utility>
 #include <vector>
 
 #include "base/command_line.h"
@@ skipping 121 matching lines @@
                  << kConstraintEffectMap[i].constraint;
       }
     }
   }
 }
 
 class P2PPortAllocatorFactory
     : public rtc::RefCountedObject<webrtc::PortAllocatorFactoryInterface> {
  public:
   P2PPortAllocatorFactory(
-      scoped_ptr<media::MediaPermission> media_permission,
+      media::MediaPermission* media_permission,
       const scoped_refptr<P2PSocketDispatcher>& socket_dispatcher,
       rtc::NetworkManager* network_manager,
       rtc::PacketSocketFactory* socket_factory,
       const P2PPortAllocator::Config& config,
       const GURL& origin,
       const scoped_refptr<base::SingleThreadTaskRunner>& task_runner)
-      : media_permission_(media_permission.Pass()),
+      : media_permission_(media_permission),
         socket_dispatcher_(socket_dispatcher),
         network_manager_(network_manager),
         socket_factory_(socket_factory),
         config_(config),
         origin_(origin),
         task_runner_(task_runner) {}
 
   cricket::PortAllocator* CreatePortAllocator(
       const std::vector<StunConfiguration>& stun_servers,
       const std::vector<TurnConfiguration>& turn_configurations) override {
     P2PPortAllocator::Config config = config_;
     for (size_t i = 0; i < stun_servers.size(); ++i) {
       config.stun_servers.insert(rtc::SocketAddress(
           stun_servers[i].server.hostname(),
           stun_servers[i].server.port()));
     }
     for (size_t i = 0; i < turn_configurations.size(); ++i) {
       P2PPortAllocator::Config::RelayServerConfig relay_config;
       relay_config.server_address = turn_configurations[i].server.hostname();
       relay_config.port = turn_configurations[i].server.port();
       relay_config.username = turn_configurations[i].username;
       relay_config.password = turn_configurations[i].password;
       relay_config.transport_type = turn_configurations[i].transport_type;
       relay_config.secure = turn_configurations[i].secure;
       config.relays.push_back(relay_config);
     }
 
     scoped_ptr<rtc::NetworkManager> network_manager;
     if (config.enable_multiple_routes) {
-      media::MediaPermission* media_permission = media_permission_.get();
       FilteringNetworkManager* filtering_network_manager =
           new FilteringNetworkManager(network_manager_, origin_,
-                                      media_permission_.Pass());
-      if (media_permission) {
+                                      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.
         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_));
     }
 
     return new P2PPortAllocator(socket_dispatcher_, network_manager.Pass(),
                                 socket_factory_, config, origin_, task_runner_);
   }
 
  protected:
   ~P2PPortAllocatorFactory() override {}
 
  private:
-  // Ownership of |media_permission_| will be passed to FilteringNetworkManager
-  // during CreatePortAllocator.
-  scoped_ptr<media::MediaPermission> media_permission_;
-
+  media::MediaPermission* media_permission_;
   scoped_refptr<P2PSocketDispatcher> socket_dispatcher_;
   rtc::NetworkManager* network_manager_;
   rtc::PacketSocketFactory* socket_factory_;
   P2PPortAllocator::Config config_;
   GURL origin_;
 
-  // This is the worker thread where |media_permission_| and |network_manager_|
-  // live on.
+  // This is the worker thread where |network_manager_| live on.
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 };
 
 PeerConnectionDependencyFactory::PeerConnectionDependencyFactory(
     P2PSocketDispatcher* p2p_socket_dispatcher)
     : network_manager_(NULL),
       p2p_socket_dispatcher_(p2p_socket_dispatcher),
       signaling_thread_(NULL),
       worker_thread_(NULL),
       chrome_signaling_thread_("Chrome_libJingle_Signaling"),
@@ skipping 238 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;
+  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().spec()).GetOrigin();
 
   scoped_refptr<P2PPortAllocatorFactory> pa_factory =
-      new P2PPortAllocatorFactory(
-          media_permission.Pass(), p2p_socket_dispatcher_, network_manager_,
-          socket_factory_.get(), port_config, requesting_origin,
-          chrome_worker_thread_.task_runner());
+      new P2PPortAllocatorFactory(media_permission, p2p_socket_dispatcher_,
+                                  network_manager_, socket_factory_.get(),
+                                  port_config, requesting_origin,
+                                  chrome_worker_thread_.task_runner());
 
   return GetPcFactory()
       ->CreatePeerConnection(config, constraints, pa_factory.get(),
                              std::move(identity_store), observer)
       .get();
 }
 
 scoped_refptr<webrtc::MediaStreamInterface>
 PeerConnectionDependencyFactory::CreateLocalMediaStream(
     const std::string& label) {
@@ skipping 255 matching lines @@
 }
 
 void PeerConnectionDependencyFactory::EnsureWebRtcAudioDeviceImpl() {
   if (audio_device_.get())
     return;
 
   audio_device_ = new WebRtcAudioDeviceImpl();
 }
 
 }  // namespace content