net: Put net/server/* into namespace net.

chrome/browser/debugger/devtools_http_protocol_handler.cc

 // Copyright (c) 2011 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/debugger/devtools_http_protocol_handler.h"
 
 #include <utility>
 
 #include "base/compiler_specific.h"
 #include "base/json/json_writer.h"
@@ skipping 19 matching lines @@
 
 const int kBufferSize = 16 * 1024;
 
 namespace {
 
 // An internal implementation of DevToolsClientHost that delegates
 // messages sent for DevToolsClient to a DebuggerShell instance.
 class DevToolsClientHostImpl : public DevToolsClientHost {
  public:
   DevToolsClientHostImpl(
-      HttpServer* server,
+      net::HttpServer* server,
       int connection_id)
       : server_(server),
         connection_id_(connection_id) {
   }
   ~DevToolsClientHostImpl() {}
 
   // DevToolsClientHost interface
   virtual void InspectedTabClosing() {
     BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
         NewRunnableMethod(server_,
-                          &HttpServer::Close,
+                          &net::HttpServer::Close,
                           connection_id_));
   }
 
   virtual void SendMessageToClient(const IPC::Message& msg) {
     IPC_BEGIN_MESSAGE_MAP(DevToolsClientHostImpl, msg)
       IPC_MESSAGE_HANDLER(DevToolsClientMsg_DispatchOnInspectorFrontend,
                           OnDispatchOnInspectorFrontend);
       IPC_MESSAGE_UNHANDLED_ERROR()
     IPC_END_MESSAGE_MAP()
   }
 
   virtual void TabReplaced(TabContentsWrapper* new_tab) {
   }
 
   void NotifyCloseListener() {
     DevToolsClientHost::NotifyCloseListener();
   }
  private:
   // Message handling routines
   void OnDispatchOnInspectorFrontend(const std::string& data) {
     BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
         NewRunnableMethod(server_,
-                          &HttpServer::SendOverWebSocket,
+                          &net::HttpServer::SendOverWebSocket,
                           connection_id_,
                           data));
   }
 
   virtual void FrameNavigating(const std::string& url) {}
-  HttpServer* server_;
+  net::HttpServer* server_;
   int connection_id_;
 };
 
 }  // namespace
 
 
 // static
 scoped_refptr<DevToolsHttpProtocolHandler> DevToolsHttpProtocolHandler::Start(
     const std::string& ip,
     int port,
@@ skipping 17 matching lines @@
 }
 
 void DevToolsHttpProtocolHandler::Stop() {
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       NewRunnableMethod(this, &DevToolsHttpProtocolHandler::Teardown));
 }
 
 void DevToolsHttpProtocolHandler::OnHttpRequest(
     int connection_id,
-    const HttpServerRequestInfo& info) {
+    const net::HttpServerRequestInfo& info) {
   if (info.path == "" || info.path == "/") {
     // Pages discovery request.
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         NewRunnableMethod(this,
                           &DevToolsHttpProtocolHandler::OnRootRequestUI,
                           connection_id,
                           info));
     return;
@@ skipping 29 matching lines @@
   net::URLRequest* request = new net::URLRequest(
       GURL("chrome-devtools:/" + info.path), this);
   Bind(request, connection_id);
   request->set_context(
       Profile::GetDefaultRequestContext()->GetURLRequestContext());
   request->Start();
 }
 
 void DevToolsHttpProtocolHandler::OnWebSocketRequest(
     int connection_id,
-    const HttpServerRequestInfo& request) {
+    const net::HttpServerRequestInfo& request) {
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       NewRunnableMethod(
           this,
           &DevToolsHttpProtocolHandler::OnWebSocketRequestUI,
           connection_id,
           request));
 }
 
@@ skipping 41 matching lines @@
   std::string url;
   bool attached;
   std::string title;
   std::string favicon_url;
 };
 typedef std::vector<PageInfo> PageList;
 
 static PageList GeneratePageList(
     DevToolsHttpProtocolHandler::TabContentsProvider* tab_contents_provider,
     int connection_id,
-    const HttpServerRequestInfo& info) {
+    const net::HttpServerRequestInfo& info) {
   typedef DevToolsHttpProtocolHandler::InspectableTabs Tabs;
   Tabs inspectable_tabs = tab_contents_provider->GetInspectableTabs();
 
   PageList page_list;
   for (Tabs::iterator it = inspectable_tabs.begin();
        it != inspectable_tabs.end(); ++it) {
 
     TabContentsWrapper* tab_contents = *it;
     NavigationController& controller = tab_contents->controller();
 
@@ skipping 10 matching lines @@
     page_info.url = entry->url().spec();
     page_info.title = UTF16ToUTF8(entry->title());
     page_info.favicon_url = entry->favicon().url().spec();
     page_list.push_back(page_info);
   }
   return page_list;
 }
 
 void DevToolsHttpProtocolHandler::OnRootRequestUI(
     int connection_id,
-    const HttpServerRequestInfo& info) {
+    const net::HttpServerRequestInfo& info) {
   std::string host = info.headers["Host"];
   std::string response = "<html><body>";
   PageList page_list = GeneratePageList(tab_contents_provider_.get(),
                                         connection_id, info);
   for (PageList::iterator i = page_list.begin();
        i != page_list.end(); ++i) {
 
     std::string frontendURL = StringPrintf("%s?host=%s&page=%d",
                                            overriden_frontend_url_.c_str(),
                                            host.c_str(),
@@ skipping 11 matching lines @@
                                i->url.c_str());
     }
     response += "</div>";
   }
   response += "</body></html>";
   Send200(connection_id, response, "text/html; charset=UTF-8");
 }
 
 void DevToolsHttpProtocolHandler::OnJsonRequestUI(
     int connection_id,
-    const HttpServerRequestInfo& info) {
+    const net::HttpServerRequestInfo& info) {
   PageList page_list = GeneratePageList(tab_contents_provider_.get(),
                                         connection_id, info);
   ListValue json_pages_list;
   std::string host = info.headers["Host"];
   for (PageList::iterator i = page_list.begin();
        i != page_list.end(); ++i) {
 
     DictionaryValue* page_info = new DictionaryValue;
     json_pages_list.Append(page_info);
     page_info->SetString("title", i->title);
@@ skipping 12 matching lines @@
     }
   }
 
   std::string response;
   base::JSONWriter::Write(&json_pages_list, true, &response);
   Send200(connection_id, response, "application/json; charset=UTF-8");
 }
 
 void DevToolsHttpProtocolHandler::OnWebSocketRequestUI(
     int connection_id,
-    const HttpServerRequestInfo& request) {
+    const net::HttpServerRequestInfo& request) {
   std::string prefix = "/devtools/page/";
   size_t pos = request.path.find(prefix);
   if (pos != 0) {
     Send404(connection_id);
     return;
   }
   std::string page_id = request.path.substr(prefix.length());
   int id = 0;
   if (!base::StringToInt(page_id, &id)) {
     Send500(connection_id, "Invalid page id: " + page_id);
@@ skipping 116 matching lines @@
     TabContentsProvider* provider)
     : ip_(ip),
       port_(port),
       overriden_frontend_url_(frontend_host),
       tab_contents_provider_(provider) {
   if (overriden_frontend_url_.empty())
       overriden_frontend_url_ = "/devtools/devtools.html";
 }
 
 void DevToolsHttpProtocolHandler::Init() {
-  server_ = new HttpServer(ip_, port_, this);
+  server_ = new net::HttpServer(ip_, port_, this);
 }
 
 // Run on I/O thread
 void DevToolsHttpProtocolHandler::Teardown() {
   server_ = NULL;
 }
 
 void DevToolsHttpProtocolHandler::Bind(net::URLRequest* request,
                                        int connection_id) {
   request_to_connection_io_[request] = connection_id;
@@ skipping 22 matching lines @@
   request_to_buffer_io_.erase(request);
   delete request;
 }
 
 void DevToolsHttpProtocolHandler::Send200(int connection_id,
                                           const std::string& data,
                                           const std::string& mime_type) {
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       NewRunnableMethod(server_.get(),
-                        &HttpServer::Send200,
+                        &net::HttpServer::Send200,
                         connection_id,
                         data,
                         mime_type));
 }
 
 void DevToolsHttpProtocolHandler::Send404(int connection_id) {
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       NewRunnableMethod(server_.get(),
-                        &HttpServer::Send404,
+                        &net::HttpServer::Send404,
                         connection_id));
 }
 
 void DevToolsHttpProtocolHandler::Send500(int connection_id,
                                           const std::string& message) {
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       NewRunnableMethod(server_.get(),
-                        &HttpServer::Send500,
+                        &net::HttpServer::Send500,
                         connection_id,
                         message));
 }
 
 void DevToolsHttpProtocolHandler::AcceptWebSocket(
     int connection_id,
-    const HttpServerRequestInfo& request) {
+    const net::HttpServerRequestInfo& request) {
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       NewRunnableMethod(server_.get(),
-                        &HttpServer::AcceptWebSocket,
+                        &net::HttpServer::AcceptWebSocket,
                         connection_id,
                         request));
 }
 
 TabContents* DevToolsHttpProtocolHandler::GetTabContents(int session_id) {
   InspectableTabs inspectable_tabs =
       tab_contents_provider_->GetInspectableTabs();
 
   for (InspectableTabs::iterator it = inspectable_tabs.begin();
        it != inspectable_tabs.end(); ++it) {
     TabContentsWrapper* tab_contents = *it;
     NavigationController& controller =
         tab_contents->controller();
     if (controller.session_id().id() == session_id)
       return controller.tab_contents();
   }
   return NULL;
 }