Bind open firewall ports to visible application windows.

extensions/browser/api/socket/socket_api.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 "extensions/browser/api/socket/socket_api.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/containers/hash_tables.h"
@@ skipping 14 matching lines @@
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 #include "net/base/net_util.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 
 #if defined(OS_CHROMEOS)
 #include "base/command_line.h"
 #include "chromeos/chromeos_switches.h"
-#include "chromeos/network/firewall_hole.h"
 #include "content/public/browser/browser_thread.h"
 #endif  // OS_CHROMEOS
 
 namespace extensions {
 
+using content::BrowserThread;
 using content::SocketPermissionRequest;
 
 const char kAddressKey[] = "address";
 const char kPortKey[] = "port";
 const char kBytesWrittenKey[] = "bytesWritten";
 const char kDataKey[] = "data";
 const char kResultCodeKey[] = "resultCode";
 const char kSocketIdKey[] = "socketId";
 
 const char kSocketNotFoundError[] = "Socket not found";
@@ skipping 59 matching lines @@
           chromeos::switches::kEnableFirewallHolePunching)) {
     net::IPEndPoint local_address;
     if (!socket->GetLocalAddress(&local_address)) {
       NOTREACHED() << "Cannot get address of recently bound socket.";
       error_ = kFirewallFailure;
       SetResult(new base::FundamentalValue(-1));
       AsyncWorkCompleted();
       return;
     }
 
-    chromeos::FirewallHole::PortType port_type;
-    if (socket->GetSocketType() == Socket::TYPE_TCP) {
-      port_type = chromeos::FirewallHole::PortType::TCP;
-    } else {
-      port_type = chromeos::FirewallHole::PortType::UDP;
-    }
+    AppFirewallHole::PortType type = socket->GetSocketType() == Socket::TYPE_TCP
+                                         ? AppFirewallHole::PortType::TCP
+                                         : AppFirewallHole::PortType::UDP;
 
-    content::BrowserThread::PostTask(
-        content::BrowserThread::UI, FROM_HERE,
-        base::Bind(
-            &chromeos::FirewallHole::Open, port_type, local_address.port(),
-            "" /* all interfaces */,
-            base::Bind(&SocketAsyncApiFunction::OnFirewallHoleOpenedOnUIThread,
-                       this, socket_id)));
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        base::Bind(&SocketAsyncApiFunction::OpenFirewallHoleOnUIThread, this,
+                   type, local_address.port(), socket_id));
     return;
   }
 #endif
   AsyncWorkCompleted();
 }
 
 #if defined(OS_CHROMEOS)
 
-void SocketAsyncApiFunction::OnFirewallHoleOpenedOnUIThread(
-    int socket_id,
-    scoped_ptr<chromeos::FirewallHole> hole) {
-  content::BrowserThread::PostTask(
-      content::BrowserThread::IO, FROM_HERE,
+void SocketAsyncApiFunction::OpenFirewallHoleOnUIThread(
+    AppFirewallHole::PortType type,
+    uint16_t port,
+    int socket_id) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  AppFirewallHoleManager* manager =
+      AppFirewallHoleManager::Get(browser_context());
+  scoped_ptr<AppFirewallHole, BrowserThread::DeleteOnUIThread> hole(
+      manager->Open(type, port, extension_id()).release());
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
       base::Bind(&SocketAsyncApiFunction::OnFirewallHoleOpened, this, socket_id,
                  base::Passed(&hole)));
 }
 
 void SocketAsyncApiFunction::OnFirewallHoleOpened(
     int socket_id,
-    scoped_ptr<chromeos::FirewallHole> hole) {
+    scoped_ptr<AppFirewallHole, BrowserThread::DeleteOnUIThread> hole) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!hole) {
     error_ = kFirewallFailure;
     SetResult(new base::FundamentalValue(-1));
     AsyncWorkCompleted();
     return;
   }
 
   Socket* socket = GetSocket(socket_id);
   if (!socket) {
     error_ = kSocketNotFoundError;
@@ skipping 603 matching lines @@
   if (socket->GetLocalAddress(&localAddress)) {
     info.local_address.reset(
         new std::string(localAddress.ToStringWithoutPort()));
     info.local_port.reset(new int(localAddress.port()));
   }
 
   SetResult(info.ToValue().release());
 }
 
 bool SocketGetNetworkListFunction::RunAsync() {
-  content::BrowserThread::PostTask(
-      content::BrowserThread::FILE,
-      FROM_HERE,
+  BrowserThread::PostTask(
+      BrowserThread::FILE, FROM_HERE,
       base::Bind(&SocketGetNetworkListFunction::GetNetworkListOnFileThread,
                  this));
   return true;
 }
 
 void SocketGetNetworkListFunction::GetNetworkListOnFileThread() {
   net::NetworkInterfaceList interface_list;
   if (GetNetworkList(&interface_list,
                      net::INCLUDE_HOST_SCOPE_VIRTUAL_INTERFACES)) {
-    content::BrowserThread::PostTask(
-        content::BrowserThread::UI,
-        FROM_HERE,
-        base::Bind(&SocketGetNetworkListFunction::SendResponseOnUIThread,
-                   this,
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        base::Bind(&SocketGetNetworkListFunction::SendResponseOnUIThread, this,
                    interface_list));
     return;
   }
 
-  content::BrowserThread::PostTask(
-      content::BrowserThread::UI,
-      FROM_HERE,
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
       base::Bind(&SocketGetNetworkListFunction::HandleGetNetworkListError,
                  this));
 }
 
 void SocketGetNetworkListFunction::HandleGetNetworkListError() {
-  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   error_ = kNetworkListError;
   SendResponse(false);
 }
 
 void SocketGetNetworkListFunction::SendResponseOnUIThread(
     const net::NetworkInterfaceList& interface_list) {
-  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   std::vector<linked_ptr<core_api::socket::NetworkInterface> > create_arg;
   create_arg.reserve(interface_list.size());
   for (net::NetworkInterfaceList::const_iterator i = interface_list.begin();
        i != interface_list.end();
        ++i) {
     linked_ptr<core_api::socket::NetworkInterface> info =
         make_linked_ptr(new core_api::socket::NetworkInterface);
     info->name = i->name;
     info->address = net::IPAddressToString(i->address);
@@ skipping 199 matching lines @@
   SetResult(values);
 }
 
 SocketSecureFunction::SocketSecureFunction() {
 }
 
 SocketSecureFunction::~SocketSecureFunction() {
 }
 
 bool SocketSecureFunction::Prepare() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   params_ = core_api::socket::Secure::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   url_request_getter_ = browser_context()->GetRequestContext();
   return true;
 }
 
 // Override the regular implementation, which would call AsyncWorkCompleted
 // immediately after Work().
 void SocketSecureFunction::AsyncWorkStart() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   Socket* socket = GetSocket(params_->socket_id);
   if (!socket) {
     SetResult(new base::FundamentalValue(net::ERR_INVALID_ARGUMENT));
     error_ = kSocketNotFoundError;
     AsyncWorkCompleted();
     return;
   }
 
   // Make sure that the socket is a TCP client socket.
@@ skipping 35 matching lines @@
   } else {
     RemoveSocket(params_->socket_id);
     error_ = net::ErrorToString(result);
   }
 
   results_ = core_api::socket::Secure::Results::Create(result);
   AsyncWorkCompleted();
 }
 
 }  // namespace extensions