[DevTools] Move SystemInfo domain to generated handler

content/browser/devtools/devtools_http_handler_impl.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 "content/browser/devtools/devtools_http_handler_impl.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_util.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/thread.h"
 #include "base/values.h"
 #include "content/browser/devtools/devtools_manager.h"
 #include "content/browser/devtools/devtools_protocol.h"
 #include "content/browser/devtools/devtools_protocol_constants.h"
-#include "content/browser/devtools/devtools_system_info_handler.h"
 #include "content/browser/devtools/protocol/devtools_protocol_handler_impl.h"
+#include "content/browser/devtools/protocol/system_info_handler.h"
 #include "content/browser/devtools/protocol/tethering_handler.h"
 #include "content/browser/devtools/protocol/tracing_handler.h"
 #include "content/common/devtools_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/devtools_http_handler_delegate.h"
 #include "content/public/browser/devtools_target.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/common/user_agent.h"
@@ skipping 119 matching lines @@
 
 class DevToolsHttpHandlerImpl::BrowserTarget {
  public:
   BrowserTarget(base::MessageLoop* message_loop,
                 net::HttpServer* server,
                 DevToolsHttpHandlerDelegate* delegate,
                 int connection_id)
       : message_loop_(message_loop),
         server_(server),
         connection_id_(connection_id),
+        system_info_handler_(new devtools::system_info::SystemInfoHandler()),
         tethering_handler_(new devtools::tethering::TetheringHandler(
             delegate, message_loop->message_loop_proxy())),
         tracing_handler_(new devtools::tracing::TracingHandler(
             devtools::tracing::TracingHandler::Browser)),
         protocol_handler_(new DevToolsProtocolHandlerImpl()) {
     protocol_handler_->SetNotifier(
         base::Bind(&BrowserTarget::Respond, base::Unretained(this)));
+    protocol_handler_->SetSystemInfoHandler(system_info_handler_.get());
     protocol_handler_->SetTetheringHandler(tethering_handler_.get());
     protocol_handler_->SetTracingHandler(tracing_handler_.get());
   }
 
-  ~BrowserTarget() {
-    STLDeleteElements(&handlers_);
-  }
-
   // Takes ownership.

[dgozman, 2014/10/28 10:19:58]

Obsolete comment.

[vkuzkokov, 2014/10/28 11:57:50]

Done.

-  void RegisterHandler(DevToolsProtocol::Handler* handler) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-    handler->SetNotifier(
-        base::Bind(&BrowserTarget::Respond, base::Unretained(this)));
-    handlers_.push_back(handler);
-  }
-
   void HandleMessage(const std::string& message) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     std::string error_response;
     scoped_refptr<DevToolsProtocol::Command> command =
         DevToolsProtocol::ParseCommand(message, &error_response);
     if (!command.get()) {
       Respond(error_response);
       return;
     }
 
     scoped_refptr<DevToolsProtocol::Response> response =
         protocol_handler_->HandleCommand(command);
-    for (const auto& handler : handlers_) {
-      if (response.get())
-        break;
-      response = handler->HandleCommand(command);
-    }
 
     if (response.get()) {
       if (!response->is_async_promise())
         Respond(response->Serialize());
     } else {
       Respond(command->NoSuchMethodErrorResponse()->Serialize());
     }
   }
 
   void Respond(const std::string& message) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     message_loop_->PostTask(
         FROM_HERE,
         base::Bind(&net::HttpServer::SendOverWebSocket,
                    base::Unretained(server_),
                    connection_id_,
                    message));
   }
 
  private:
   base::MessageLoop* const message_loop_;
   net::HttpServer* const server_;
   const int connection_id_;
+  scoped_ptr<devtools::system_info::SystemInfoHandler> system_info_handler_;
   scoped_ptr<devtools::tethering::TetheringHandler> tethering_handler_;
   scoped_ptr<devtools::tracing::TracingHandler> tracing_handler_;
   scoped_ptr<DevToolsProtocolHandlerImpl> protocol_handler_;
-  std::vector<DevToolsProtocol::Handler*> handlers_;
 };
 
 // DevToolsHttpHandler -------------------------------------------------------
 
 // static
 bool DevToolsHttpHandler::IsSupportedProtocolVersion(
     const std::string& version) {
   return devtools::IsSupportedProtocolVersion(version);
 }
 
@@ skipping 457 matching lines @@
 
 void DevToolsHttpHandlerImpl::OnWebSocketRequestUI(
     int connection_id,
     const net::HttpServerRequestInfo& request) {
   if (!thread_)
     return;
 
   std::string browser_prefix = "/devtools/browser";
   size_t browser_pos = request.path.find(browser_prefix);
   if (browser_pos == 0) {
-    BrowserTarget* browser_target = new BrowserTarget(
+    browser_targets_[connection_id] = new BrowserTarget(
         thread_->message_loop(), server_.get(), delegate_.get(), connection_id);
-    browser_target->RegisterHandler(
-        new DevToolsSystemInfoHandler());
-    browser_targets_[connection_id] = browser_target;
     AcceptWebSocket(connection_id, request);
     return;
   }
 
   size_t pos = request.path.find(kPageUrlPrefix);
   if (pos != 0) {
     Send404(connection_id);
     return;
   }
 
@@ skipping 249 matching lines @@
         id.c_str(),
         host);
     dictionary->SetString(
         kTargetDevtoolsFrontendUrlField, devtools_frontend_url);
   }
 
   return dictionary;
 }
 
 }  // namespace content