[Device Discovery] Move files from browser/extensions/api/dial to browser/media/router/discovery/di…

chrome/browser/media/router/discovery/dial/dial_service.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 "chrome/browser/extensions/api/dial/dial_service.h"
+#include "chrome/browser/media/router/discovery/dial/dial_service.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <set>
 #include <utility>
 
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/rand_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
-#include "chrome/browser/extensions/api/dial/dial_device_data.h"
+#include "chrome/browser/media/router/discovery/dial/dial_device_data.h"
 #include "components/version_info/version_info.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/address_family.h"
 #include "net/base/completion_callback.h"
 #include "net/base/io_buffer.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "net/base/network_interfaces.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_util.h"
@@ skipping 12 matching lines @@
 using content::BrowserThread;
 using net::HttpResponseHeaders;
 using net::HttpUtil;
 using net::IOBufferWithSize;
 using net::IPAddress;
 using net::NetworkInterface;
 using net::NetworkInterfaceList;
 using net::StringIOBuffer;
 using net::UDPSocket;
 
-namespace extensions {
-namespace api {
-namespace dial {
+namespace media_router {
 
 namespace {
 
 // The total number of requests to make per discovery cycle.
 const int kDialMaxRequests = 4;
 
 // The interval to wait between successive requests.
 const int kDialRequestIntervalMillis = 1000;
 
 // The maximum delay a device may wait before responding (MX).
@@ skipping 14 matching lines @@
 // SSDP headers parsed from the response.
 const char kSsdpLocationHeader[] = "LOCATION";
 const char kSsdpCacheControlHeader[] = "CACHE-CONTROL";
 const char kSsdpConfigIdHeader[] = "CONFIGID.UPNP.ORG";
 const char kSsdpUsnHeader[] = "USN";
 
 // The receive buffer size, in bytes.
 const int kDialRecvBufferSize = 1500;
 
 // Gets a specific header from |headers| and puts it in |value|.
-bool GetHeader(HttpResponseHeaders* headers, const char* name,
+bool GetHeader(HttpResponseHeaders* headers,
+               const char* name,
                std::string* value) {
   return headers->EnumerateHeader(nullptr, std::string(name), value);
 }
 
 // Returns the request string.
 std::string BuildRequest() {
   // Extra line at the end to make UPnP lib happy.
   std::string request(base::StringPrintf(
       "M-SEARCH * HTTP/1.1\r\n"
       "HOST: %s:%u\r\n"
       "MAN: \"ssdp:discover\"\r\n"
       "MX: %d\r\n"
       "ST: %s\r\n"
       "USER-AGENT: %s/%s %s\r\n"
       "\r\n",
-      kDialRequestAddress,
-      kDialRequestPort,
-      kDialMaxResponseDelaySecs,
-      kDialSearchType,
-      version_info::GetProductName().c_str(),
+      kDialRequestAddress, kDialRequestPort, kDialMaxResponseDelaySecs,
+      kDialSearchType, version_info::GetProductName().c_str(),
       version_info::GetVersionNumber().c_str(),
       version_info::GetOSType().c_str()));
   // 1500 is a good MTU value for most Ethernet LANs.
   DCHECK_LE(request.size(), 1500U);
   return request;
 }
 
 #if defined(OS_CHROMEOS)
 // Finds the IP address of the preferred interface of network type |type|
 // to bind the socket and inserts the address into |bind_address_list|. This
 // ChromeOS version can prioritize wifi and ethernet interfaces.
 void InsertBestBindAddressChromeOS(const chromeos::NetworkTypePattern& type,
                                    net::IPAddressList* bind_address_list) {
   const chromeos::NetworkState* state = chromeos::NetworkHandler::Get()
-      ->network_state_handler()->ConnectedNetworkByType(type);
+                                            ->network_state_handler()
+                                            ->ConnectedNetworkByType(type);
   IPAddress bind_ip_address;
   if (state && bind_ip_address.AssignFromIPLiteral(state->ip_address()) &&
       bind_ip_address.IsIPv4()) {
     VLOG(2) << "Found " << state->type() << ", " << state->name() << ": "
             << state->ip_address();
     bind_address_list->push_back(bind_ip_address);
   }
 }
 #else
 NetworkInterfaceList GetNetworkListOnFileThread() {
@@ skipping 57 matching lines @@
     VLOG(1) << "Socket not connected.";
     return;
   }
 
   if (is_writing_) {
     VLOG(1) << "Already writing.";
     return;
   }
 
   is_writing_ = true;
-  int result = socket_->SendTo(
-      send_buffer.get(), send_buffer->size(), send_address,
-      base::Bind(&DialServiceImpl::DialSocket::OnSocketWrite,
-                 base::Unretained(this),
-                 send_buffer->size()));
+  int result =
+      socket_->SendTo(send_buffer.get(), send_buffer->size(), send_address,
+                      base::Bind(&DialServiceImpl::DialSocket::OnSocketWrite,
+                                 base::Unretained(this), send_buffer->size()));
   bool result_ok = CheckResult("SendTo", result);
   if (result_ok && result > 0) {
     // Synchronous write.
     OnSocketWrite(send_buffer->size(), result);
   }
 }
 
 bool DialServiceImpl::DialSocket::IsClosed() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   return !socket_;
@@ skipping 20 matching lines @@
   socket_.reset();
 }
 
 void DialServiceImpl::DialSocket::OnSocketWrite(int send_buffer_size,
                                                 int result) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   is_writing_ = false;
   if (!CheckResult("OnSocketWrite", result))
     return;
   if (result != send_buffer_size) {
-    VLOG(1) << "Sent " << result << " chars, expected "
-            << send_buffer_size << " chars";
+    VLOG(1) << "Sent " << result << " chars, expected " << send_buffer_size
+            << " chars";
   }
   discovery_request_cb_.Run();
 }
 
 bool DialServiceImpl::DialSocket::ReadSocket() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!socket_) {
     VLOG(1) << "Socket not connected.";
     return false;
   }
 
   if (is_reading_) {
     VLOG(1) << "Already reading.";
     return false;
   }
 
   int result = net::OK;
   bool result_ok = true;
   do {
     is_reading_ = true;
     result = socket_->RecvFrom(
-        recv_buffer_.get(),
-        kDialRecvBufferSize, &recv_address_,
+        recv_buffer_.get(), kDialRecvBufferSize, &recv_address_,
         base::Bind(&DialServiceImpl::DialSocket::OnSocketRead,
                    base::Unretained(this)));
     result_ok = CheckResult("RecvFrom", result);
     if (result != net::ERR_IO_PENDING)
       is_reading_ = false;
     if (result_ok && result > 0) {
       // Synchronous read.
       HandleResponse(result);
     }
   } while (result_ok && result != net::OK && result != net::ERR_IO_PENDING);
@@ skipping 25 matching lines @@
   std::string response(recv_buffer_->data(), bytes_read);
   Time response_time = Time::Now();
 
   // Attempt to parse response, notify observers if successful.
   DialDeviceData parsed_device;
   if (ParseResponse(response, response_time, &parsed_device))
     device_discovered_cb_.Run(parsed_device);
 }
 
 // static
-bool DialServiceImpl::DialSocket::ParseResponse(
-    const std::string& response,
-    const base::Time& response_time,
-    DialDeviceData* device) {
-  int headers_end = HttpUtil::LocateEndOfHeaders(response.c_str(),
-                                                 response.size());
+bool DialServiceImpl::DialSocket::ParseResponse(const std::string& response,
+                                                const base::Time& response_time,
+                                                DialDeviceData* device) {
+  int headers_end =
+      HttpUtil::LocateEndOfHeaders(response.c_str(), response.size());
   if (headers_end < 1) {
     VLOG(1) << "Headers invalid or empty, ignoring: " << response;
     return false;
   }
   std::string raw_headers =
       HttpUtil::AssembleRawHeaders(response.c_str(), headers_end);
   VLOG(3) << "raw_headers: " << raw_headers << "\n";
   scoped_refptr<HttpResponseHeaders> headers =
       new HttpResponseHeaders(raw_headers);
 
@@ skipping 130 matching lines @@
   // is used to identify unique interfaces.
   // TODO(mfoltz): Support IPV6 multicast.  http://crbug.com/165286
   for (NetworkInterfaceList::const_iterator iter = networks.begin();
        iter != networks.end(); ++iter) {
     net::AddressFamily addr_family = net::GetAddressFamily(iter->address);
     VLOG(2) << "Found " << iter->name << ", " << iter->address.ToString()
             << ", address family: " << addr_family;
     if (addr_family == net::ADDRESS_FAMILY_IPV4) {
       InterfaceIndexAddressFamily interface_index_addr_family =
           std::make_pair(iter->interface_index, addr_family);
-      bool inserted = interface_index_addr_family_seen
-          .insert(interface_index_addr_family)
-          .second;
+      bool inserted =
+          interface_index_addr_family_seen.insert(interface_index_addr_family)
+              .second;
       // We have not seen this interface before, so add its IP address to the
       // discovery list.
       if (inserted) {
         VLOG(2) << "Encountered "
                 << "interface index: " << iter->interface_index << ", "
                 << "address family: " << addr_family << " for the first time, "
                 << "adding IP address " << iter->address.ToString()
                 << " to list.";
         ip_addresses.push_back(iter->address);
       } else {
@@ skipping 11 matching lines @@
     const net::IPAddressList& ip_addresses) {
   if (ip_addresses.empty()) {
     VLOG(1) << "Could not find a valid interface to bind. Finishing discovery";
     FinishDiscovery();
     return;
   }
 
   // Schedule a timer to finish the discovery process (and close the sockets).
   if (finish_delay_ > TimeDelta::FromSeconds(0)) {
     VLOG(2) << "Starting timer to finish discovery.";
-    finish_timer_.Start(FROM_HERE,
-                        finish_delay_,
-                        this,
+    finish_timer_.Start(FROM_HERE, finish_delay_, this,
                         &DialServiceImpl::FinishDiscovery);
   }
 
   for (const auto& address : ip_addresses) {
     BindAndAddSocket(address);
   }
 
   SendOneRequest();
 }
 
@@ skipping 15 matching lines @@
 }
 
 void DialServiceImpl::SendOneRequest() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (num_requests_sent_ == max_requests_) {
     VLOG(2) << "Reached max requests; stopping request timer.";
     request_timer_.Stop();
     return;
   }
   num_requests_sent_++;
-  VLOG(2) << "Sending request " << num_requests_sent_ << "/"
-          << max_requests_;
+  VLOG(2) << "Sending request " << num_requests_sent_ << "/" << max_requests_;
   for (const auto& socket : dial_sockets_) {
     if (!socket->IsClosed())
       socket->SendOneRequest(send_address_, send_buffer_);
   }
 }
 
 void DialServiceImpl::NotifyOnDiscoveryRequest() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   // If discovery is inactive, no reason to notify observers.
   if (!discovery_active_) {
     VLOG(2) << "Request sent after discovery finished.  Ignoring.";
     return;
   }
 
   VLOG(2) << "Notifying observers of discovery request";
   for (auto& observer : observer_list_)
     observer.OnDiscoveryRequest(this);
   // If we need to send additional requests, schedule a timer to do so.
   if (num_requests_sent_ < max_requests_ && num_requests_sent_ == 1) {
     VLOG(2) << "Scheduling timer to send additional requests";
     // TODO(imcheng): Move this to SendOneRequest() once the implications are
     // understood.
-    request_timer_.Start(FROM_HERE,
-                         request_interval_,
-                         this,
+    request_timer_.Start(FROM_HERE, request_interval_, this,
                          &DialServiceImpl::SendOneRequest);
   }
 }
 
 void DialServiceImpl::NotifyOnDeviceDiscovered(
     const DialDeviceData& device_data) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!discovery_active_) {
     VLOG(2) << "Got response after discovery finished.  Ignoring.";
     return;
@@ skipping 27 matching lines @@
 }
 
 bool DialServiceImpl::HasOpenSockets() {
   for (const auto& socket : dial_sockets_) {
     if (!socket->IsClosed())
       return true;
   }
   return false;
 }
 
-}  // namespace dial
-}  // namespace api
-}  // namespace extensions
+}  // namespace media_router