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

content/renderer/media/webrtc/peer_connection_dependency_factory.cc

Index: content/renderer/media/webrtc/peer_connection_dependency_factory.cc
diff --git a/content/renderer/media/webrtc/peer_connection_dependency_factory.cc b/content/renderer/media/webrtc/peer_connection_dependency_factory.cc
index 663f61869c45cc70b43a6b0e2931f2af057effe6..9664bc1a3aa70706f43b219e7b478d29c69bf429 100644
--- a/content/renderer/media/webrtc/peer_connection_dependency_factory.cc
+++ b/content/renderer/media/webrtc/peer_connection_dependency_factory.cc
@@ -8,6 +8,7 @@
 
 #include "base/command_line.h"
 #include "base/location.h"
+#include "base/metrics/field_trial.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/waitable_event.h"
 #include "content/common/media/media_stream_messages.h"
@@ -32,12 +33,16 @@
 #include "content/renderer/media/webrtc_local_audio_track.h"
 #include "content/renderer/media/webrtc_logging.h"
 #include "content/renderer/media/webrtc_uma_histograms.h"
+#include "content/renderer/p2p/empty_network_manager.h"
+#include "content/renderer/p2p/filtering_network_manager.h"
 #include "content/renderer/p2p/ipc_network_manager.h"
 #include "content/renderer/p2p/ipc_socket_factory.h"
 #include "content/renderer/p2p/port_allocator.h"
+#include "content/renderer/render_frame_impl.h"
 #include "content/renderer/render_thread_impl.h"
 #include "content/renderer/render_view_impl.h"
 #include "jingle/glue/thread_wrapper.h"
+#include "media/base/media_permission.h"
 #include "media/renderers/gpu_video_accelerator_factories.h"
 #include "third_party/WebKit/public/platform/WebMediaConstraints.h"
 #include "third_party/WebKit/public/platform/WebMediaStream.h"
@@ -108,21 +113,18 @@ void HarmonizeConstraintsAndEffects(RTCMediaConstraints* constraints,
 
 class P2PPortAllocatorFactory : public webrtc::PortAllocatorFactoryInterface {
  public:
-  P2PPortAllocatorFactory(P2PSocketDispatcher* socket_dispatcher,
-                          rtc::NetworkManager* network_manager,
-                          rtc::PacketSocketFactory* socket_factory,
-                          const GURL& origin,
-                          const P2PPortAllocator::Config& config)
-      : socket_dispatcher_(socket_dispatcher),
-        network_manager_(network_manager),
-        socket_factory_(socket_factory),
-        origin_(origin),
-        config_(config) {}
+  P2PPortAllocatorFactory(
+      scoped_ptr<media::MediaPermission>& media_permission,
+      const FilteringNetworkManager::Params& network_manager_params,
+      const P2PPortAllocator::Params& port_allocator_params)
+      : media_permission_(media_permission.Pass()),
+        network_manager_params_(network_manager_params),
+        port_allocator_params_(port_allocator_params) {}
 
   cricket::PortAllocator* CreatePortAllocator(
       const std::vector<StunConfiguration>& stun_servers,
       const std::vector<TurnConfiguration>& turn_configurations) override {
-    P2PPortAllocator::Config config = config_;
+    P2PPortAllocator::Config config = port_allocator_params_.config;
     for (size_t i = 0; i < stun_servers.size(); ++i) {
       config.stun_servers.insert(rtc::SocketAddress(
           stun_servers[i].server.hostname(),
@@ -139,28 +141,40 @@ class P2PPortAllocatorFactory : public webrtc::PortAllocatorFactoryInterface {
       config.relays.push_back(relay_config);
     }
 
-    return new P2PPortAllocator(
-        socket_dispatcher_.get(), network_manager_,
-        socket_factory_, config, origin_);
+    // If the experiment is not enabled, turn off the permission check by
+    // passing nullptr to FilteringNetworkManager constructor.
+    scoped_ptr<media::MediaPermission> media_permission(
+        media_permission_.Pass());
+    if (base::FieldTrialList::FindFullName("WebRTC-LocalIPPermissionCheck") !=
+        "Enabled") {
+      media_permission = nullptr;
+    }
+
+    scoped_ptr<rtc::NetworkManager> network_manager;
+    if (port_allocator_params_.config.enable_multiple_routes) {
+      network_manager.reset(new FilteringNetworkManager(
+          network_manager_params_, media_permission.Pass()));
+    } else {
+      network_manager.reset(
+          new EmptyNetworkManager(network_manager_params_.task_runner));
+    }
+
+    return new P2PPortAllocator(port_allocator_params_, network_manager.Pass());
   }
 
  protected:
   ~P2PPortAllocatorFactory() override {}
 
  private:
-  scoped_refptr<P2PSocketDispatcher> socket_dispatcher_;
-  // |network_manager_| and |socket_factory_| are a weak references, owned by
+  // |media_permission_| is a raw pointer, owned by
   // PeerConnectionDependencyFactory.
-  rtc::NetworkManager* network_manager_;
-  rtc::PacketSocketFactory* socket_factory_;
-  // The origin URL of the WebFrame that created the
-  // P2PPortAllocatorFactory.
-  GURL origin_;
-
-  // Keep track of configuration common to all PortAllocators created by this
-  // factory; additional, per-allocator configuration is passed into
-  // CreatePortAllocator.
-  P2PPortAllocator::Config config_;
+  scoped_ptr<media::MediaPermission> media_permission_;
+
+  // The parameters required to construct FilteringNetworkManager.
+  FilteringNetworkManager::Params network_manager_params_;
+
+  // The parameters required to construct P2PPortAllocator.
+  P2PPortAllocator::Params port_allocator_params_;
 };
 
 PeerConnectionDependencyFactory::PeerConnectionDependencyFactory(
@@ -402,25 +416,51 @@ PeerConnectionDependencyFactory::CreatePeerConnection(
           GURL(web_frame->document().url()),
           GURL(web_frame->document().firstPartyForCookies())));
 
+  // |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..
+  scoped_ptr<media::MediaPermission> media_permission;
+  RenderFrameImpl* render_frame = RenderFrameImpl::FromWebFrame(web_frame);
+  if (render_frame) {
+    media_permission = render_frame->CreateMediaPermissionProxy(
+        chrome_worker_thread_.task_runner());
+    DCHECK(media_permission);
+  }
+
   // Copy the flag from Preference associated with this WebFrame.
-  P2PPortAllocator::Config pref_config;
+  P2PPortAllocator::Config port_config;
   if (web_frame && web_frame->view()) {
     RenderViewImpl* renderer_view_impl =
         RenderViewImpl::FromWebView(web_frame->view());
     if (renderer_view_impl) {
-      pref_config.enable_multiple_routes =
+      // TODO(guoweis): |enable_multiple_routes| should be renamed to
+      // |request_multiple_routes|. Whether local IP addresses could be
+      // collected depends on if mic/camera permission is granted for this
+      // origin. If |media_permission| is nullptr, treat it as if the permission
+      // was not requested.
+      port_config.enable_multiple_routes =
           renderer_view_impl->renderer_preferences()
-              .enable_webrtc_multiple_routes;
-      pref_config.enable_nonproxied_udp =
+              .enable_webrtc_multiple_routes &&
+          (media_permission != nullptr);
+      port_config.enable_nonproxied_udp =
           renderer_view_impl->renderer_preferences()
               .enable_webrtc_nonproxied_udp;
     }
   }
 
+  const GURL& requesting_origin =
+      GURL(web_frame->document().url().spec()).GetOrigin();
+  FilteringNetworkManager::Params network_manager_params(
+      network_manager_, chrome_worker_thread_.task_runner(), requesting_origin);
+
+  P2PPortAllocator::Params port_allocator_params(
+      p2p_socket_dispatcher_, socket_factory_.get(), requesting_origin,
+      port_config);
+
   scoped_refptr<P2PPortAllocatorFactory> pa_factory =
       new rtc::RefCountedObject<P2PPortAllocatorFactory>(
-          p2p_socket_dispatcher_.get(), network_manager_, socket_factory_.get(),
-          GURL(web_frame->document().url().spec()).GetOrigin(), pref_config);
+          media_permission.Pass(), network_manager_params,
+          port_allocator_params);
 
   return GetPcFactory()->CreatePeerConnection(config,
                                               constraints,