[DevTools] Rework DevToolsSession interaction with domain handlers.

content/browser/devtools/devtools_session.cc

 // Copyright 2016 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_session.h"
 
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "content/browser/devtools/devtools_agent_host_impl.h"
 #include "content/browser/devtools/devtools_manager.h"
+#include "content/browser/devtools/protocol/input_handler.h"
+#include "content/browser/devtools/protocol/inspector_handler.h"
+#include "content/browser/devtools/protocol/network_handler.h"
+#include "content/browser/devtools/protocol/page_handler.h"
 #include "content/browser/devtools/protocol/protocol.h"
+#include "content/browser/devtools/protocol/target_handler.h"
+#include "content/browser/devtools/protocol/tracing_handler.h"
 #include "content/public/browser/devtools_manager_delegate.h"
 
 namespace content {
 
 DevToolsSession::DevToolsSession(
     DevToolsAgentHostImpl* agent_host,
+    DevToolsAgentHostClient* client,
     int session_id)
     : agent_host_(agent_host),
+      client_(client),
       session_id_(session_id),
+      host_(nullptr),
+      attached_(false),
       dispatcher_(new protocol::UberDispatcher(this)) {
 }
 
 DevToolsSession::~DevToolsSession() {}
 
-void DevToolsSession::ResetDispatcher() {
+void DevToolsSession::AddHandler(
+    std::unique_ptr<protocol::DevToolsDomainHandler> handler) {
+  handlers_[handler->name()] = std::move(handler);
+}
+
+void DevToolsSession::SetRenderFrameHost(RenderFrameHostImpl* host) {
+  host_ = host;
+  if (!attached_)
+    return;
+  for (auto& pair : handlers_)
+    pair.second->SetRenderFrameHost(host_);
+}
+
+void DevToolsSession::SetFallThroughForNotFound(bool value) {
+  dispatcher_->setFallThroughForNotFound(value);
+}
+
+void DevToolsSession::Attach() {
+  for (auto& pair : handlers_) {
+    pair.second->Wire(dispatcher_.get());
+    pair.second->SetRenderFrameHost(host_);
+  }
+  attached_ = true;
+}
+
+void DevToolsSession::Detach() {
+  attached_ = false;
   dispatcher_.reset();
+  for (auto& pair : handlers_)
+    pair.second->Disable();
+  handlers_.clear();
 }
 
 protocol::Response::Status DevToolsSession::Dispatch(
     const std::string& message,
+    bool offer_to_delegate,
     int* call_id,
     std::string* method) {
   std::unique_ptr<base::Value> value = base::JSONReader::Read(message);
 
   DevToolsManagerDelegate* delegate =
       DevToolsManager::GetInstance()->delegate();
   if (value && value->IsType(base::Value::Type::DICTIONARY) && delegate) {
     std::unique_ptr<base::DictionaryValue> response(delegate->HandleCommand(
         agent_host_,
         static_cast<base::DictionaryValue*>(value.get())));
@@ skipping 16 matching lines @@
 }
 
 void DevToolsSession::sendProtocolNotification(
     std::unique_ptr<protocol::Serializable> message) {
   agent_host_->SendMessageToClient(session_id_, message->serialize());
 }
 
 void DevToolsSession::flushProtocolNotifications() {
 }
 
+protocol::DevToolsDomainHandler* DevToolsSession::GetHandlerByName(
+    const std::string& name) {
+  auto it = handlers_.find(name);
+  if (it == handlers_.end())
+    return nullptr;
+  return it->second.get();
+}
+
+protocol::InputHandler* DevToolsSession::GetInputHandler() {
+  return static_cast<protocol::InputHandler*>(
+      GetHandlerByName(protocol::Input::Metainfo::domainName));
+}
+
+protocol::InspectorHandler* DevToolsSession::GetInspectorHandler() {
+  return static_cast<protocol::InspectorHandler*>(
+      GetHandlerByName(protocol::Inspector::Metainfo::domainName));
+}
+
+protocol::NetworkHandler* DevToolsSession::GetNetworkHandler() {
+  return static_cast<protocol::NetworkHandler*>(
+      GetHandlerByName(protocol::Network::Metainfo::domainName));
+}
+
+protocol::PageHandler* DevToolsSession::GetPageHandler() {
+  return static_cast<protocol::PageHandler*>(
+      GetHandlerByName(protocol::Page::Metainfo::domainName));
+}
+
+protocol::TargetHandler* DevToolsSession::GetTargetHandler() {
+  return static_cast<protocol::TargetHandler*>(
+      GetHandlerByName(protocol::Target::Metainfo::domainName));
+}
+
+protocol::TracingHandler* DevToolsSession::GetTracingHandler() {
+  return static_cast<protocol::TracingHandler*>(
+      GetHandlerByName(protocol::Tracing::Metainfo::domainName));
+}
+
 }  // namespace content