Check media permissions (mic/camera) before exposing local addresses to WebRTC.

content/renderer/p2p/port_allocator.cc

 // Copyright (c) 2012 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/p2p/port_allocator.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "content/public/common/content_switches.h"
+#include "content/renderer/p2p/socket_dispatcher.h"
 
 namespace content {
 
 P2PPortAllocator::Config::Config() {}
 
 P2PPortAllocator::Config::~Config() {
 }
 
 P2PPortAllocator::Config::RelayServerConfig::RelayServerConfig()
     : port(0) {
 }
 
 P2PPortAllocator::Config::RelayServerConfig::~RelayServerConfig() {
 }
 
+P2PPortAllocator::Params::Params(
+    const scoped_refptr<P2PSocketDispatcher>& socket_dispatcher,
+    rtc::PacketSocketFactory* socket_factory,
+    const GURL& origin,
+    const Config& config)
+    : socket_dispatcher(socket_dispatcher),
+      socket_factory(socket_factory),
+      requesting_origin(origin),
+      config(config) {}
+
+P2PPortAllocator::Params::~Params() {}
+
 P2PPortAllocator::P2PPortAllocator(
-    P2PSocketDispatcher* socket_dispatcher,
-    rtc::NetworkManager* network_manager,
-    rtc::PacketSocketFactory* socket_factory,
-    const Config& config,
-    const GURL& origin)
-    : cricket::BasicPortAllocator(network_manager, socket_factory),
-      socket_dispatcher_(socket_dispatcher),
-      config_(config),
-      origin_(origin)
-  {
+    const Params& params,
+    scoped_ptr<rtc::NetworkManager> network_manager)
+    : cricket::BasicPortAllocator(network_manager.get(), params.socket_factory),
+      network_manager_(network_manager.Pass()),
+      socket_dispatcher_(params.socket_dispatcher),
+      config_(params.config),
+      origin_(params.requesting_origin) {
   uint32 flags = 0;
   if (!config_.enable_multiple_routes)
     flags |= cricket::PORTALLOCATOR_DISABLE_ADAPTER_ENUMERATION;
   if (!config_.enable_nonproxied_udp) {
     flags |= cricket::PORTALLOCATOR_DISABLE_UDP |
              cricket::PORTALLOCATOR_DISABLE_STUN |
              cricket::PORTALLOCATOR_DISABLE_UDP_RELAY;
   }
   set_flags(flags);
   set_allow_tcp_listen(false);
   const base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
   bool enable_webrtc_stun_origin =
       cmd_line->HasSwitch(switches::kEnableWebRtcStunOrigin);
   if (enable_webrtc_stun_origin) {
-    set_origin(origin.spec());
+    set_origin(origin_.spec());
   }
 }
 
 P2PPortAllocator::~P2PPortAllocator() {
 }
 
 cricket::PortAllocatorSession* P2PPortAllocator::CreateSessionInternal(
     const std::string& content_name,
     int component,
     const std::string& ice_username_fragment,
@@ skipping 44 matching lines @@
                                  config.relays[i].port),
         protocol,
         config.relays[i].secure));
     relay_server.credentials = credentials;
     port_config->AddRelay(relay_server);
   }
   ConfigReady(port_config);
 }
 
 }  // namespace content