Bind before sandbox lockdown on Windows.

Linux is unaffected. All changed code already is inside sandbox.

BUG=348692

Committed: https://src.chromium.org/viewvc/chrome?view=rev&revision=255311

Review URL: https://codereview.chromium.org/185293014

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@255900 0039d316-1c4b-4281-b951-d872f2087c98

chrome/utility/local_discovery/service_discovery_message_handler.cc

@@ -66,38 +66,36 @@ class PreCreatedMDnsSocketFactory : public net::MDnsSocketFactory {
  public:
   PreCreatedMDnsSocketFactory() {}
   virtual ~PreCreatedMDnsSocketFactory() {
-    Reset();
+    // Not empty if process exits too fast, before starting mDns code. If
+    // happened, destructors may crash accessing destroyed global objects.
+    sockets_.weak_clear();
   }
 
   // net::MDnsSocketFactory implementation:
   virtual void CreateSockets(
       ScopedVector<net::DatagramServerSocket>* sockets) OVERRIDE {
-    for (size_t i = 0; i < sockets_.size(); ++i) {
-      // Takes ownership of sockets_[i].socket;
-      ScopedSocketFactory platform_factory(sockets_[i].socket);
-      scoped_ptr<net::DatagramServerSocket> socket(
-          net::CreateAndBindMDnsSocket(sockets_[i].address_family,
-                                       sockets_[i].interface_index));
-      if (socket)
-        sockets->push_back(socket.release());
-    }
-    sockets_.clear();
+    sockets->swap(sockets_);
+    Reset();
   }
 
-  void AddSocket(const SocketInfo& socket) {
-    sockets_.push_back(socket);
+  void AddSocket(const SocketInfo& socket_info) {
+    // Takes ownership of socket_info.socket;
+    ScopedSocketFactory platform_factory(socket_info.socket);
+    scoped_ptr<net::DatagramServerSocket> socket(
+        net::CreateAndBindMDnsSocket(socket_info.address_family,
+                                     socket_info.interface_index));
+    if (socket) {
+      socket->DetachFromThread();
+      sockets_.push_back(socket.release());
+    }
   }
 
   void Reset() {
-    for (size_t i = 0; i < sockets_.size(); ++i) {
-      if (sockets_[i].socket != net::kInvalidSocket)
-        ClosePlatformSocket(sockets_[i].socket);
-    }
     sockets_.clear();
   }
 
  private:
-  std::vector<SocketInfo> sockets_;
+  ScopedVector<net::DatagramServerSocket> sockets_;
 
   DISALLOW_COPY_AND_ASSIGN(PreCreatedMDnsSocketFactory);
 };

content/browser/renderer_host/p2p/socket_host_udp_unittest.cc

@@ -160,6 +160,10 @@ class FakeDatagramServerSocket : public net::DatagramServerSocket {
     return net::ERR_NOT_IMPLEMENTED;
   }
 
+  virtual void DetachFromThread() OVERRIDE {
+    NOTIMPLEMENTED();
+  }
+
  private:
   net::IPEndPoint address_;
   std::deque<UDPPacket>* sent_packets_;

net/dns/mock_mdns_socket_factory.h

@@ -54,6 +54,8 @@ class MockMDnsDatagramServerSocket : public DatagramServerSocket {
 
   MOCK_METHOD1(SetDiffServCodePoint, int(DiffServCodePoint dscp));
 
+  MOCK_METHOD0(DetachFromThread, void());
+
   void SetResponsePacket(std::string response_packet);
 
   int HandleRecvNow(IOBuffer* buffer, int size, IPEndPoint* address,

net/udp/datagram_server_socket.h

@@ -103,6 +103,9 @@ class NET_EXPORT DatagramServerSocket : public DatagramSocket {
   // Set the Differentiated Services Code Point. May do nothing on
   // some platforms. Returns a network error code.
   virtual int SetDiffServCodePoint(DiffServCodePoint dscp) = 0;
+
+  // Resets the thread to be used for thread-safety checks.
+  virtual void DetachFromThread() = 0;
 };
 
 }  // namespace net

net/udp/udp_server_socket.cc

@@ -93,4 +93,8 @@ int UDPServerSocket::SetDiffServCodePoint(DiffServCodePoint dscp) {
   return socket_.SetDiffServCodePoint(dscp);
 }
 
+void UDPServerSocket::DetachFromThread() {
+  socket_.DetachFromThread();
+}
+
 }  // namespace net

net/udp/udp_server_socket.h

@@ -45,6 +45,7 @@ class NET_EXPORT UDPServerSocket : public DatagramServerSocket {
   virtual int SetMulticastTimeToLive(int time_to_live) OVERRIDE;
   virtual int SetMulticastLoopbackMode(bool loopback) OVERRIDE;
   virtual int SetDiffServCodePoint(DiffServCodePoint dscp) OVERRIDE;
+  virtual void DetachFromThread() OVERRIDE;
 
  private:
   UDPSocket socket_;

net/udp/udp_socket_libevent.cc

@@ -767,4 +767,8 @@ int UDPSocketLibevent::SetDiffServCodePoint(DiffServCodePoint dscp) {
   return OK;
 }
 
+void UDPSocketLibevent::DetachFromThread() {
+  base::NonThreadSafe::DetachFromThread();
+}
+
 }  // namespace net

net/udp/udp_socket_libevent.h

@@ -163,6 +163,9 @@ class NET_EXPORT UDPSocketLibevent : public base::NonThreadSafe {
   // Return a network error code.
   int SetDiffServCodePoint(DiffServCodePoint dscp);
 
+  // Resets the thread to be used for thread-safety checks.
+  void DetachFromThread();
+
  private:
   enum SocketOptions {
     SOCKET_OPTION_REUSE_ADDRESS  = 1 << 0,

net/udp/udp_socket_win.cc

@@ -810,4 +810,8 @@ int UDPSocketWin::SetDiffServCodePoint(DiffServCodePoint dscp) {
   return ERR_NOT_IMPLEMENTED;
 }
 
+void UDPSocketWin::DetachFromThread() {
+  base::NonThreadSafe::DetachFromThread();
+}
+
 }  // namespace net

net/udp/udp_socket_win.h

@@ -161,6 +161,9 @@ class NET_EXPORT UDPSocketWin : NON_EXPORTED_BASE(public base::NonThreadSafe) {
   // do anything on some platforms.
   int SetDiffServCodePoint(DiffServCodePoint dscp);
 
+  // Resets the thread to be used for thread-safety checks.
+  void DetachFromThread();
+
  private:
   enum SocketOptions {
     SOCKET_OPTION_REUSE_ADDRESS  = 1 << 0,