Revert of DevTools: merge devtools target with devtools host, part 1

components/devtools_http_handler/devtools_http_handler.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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <utility>
 
@@ skipping 306 matching lines @@
 
  private:
   base::MessageLoop* const message_loop_;
   ServerWrapper* const server_wrapper_;
   const int connection_id_;
   scoped_refptr<DevToolsAgentHost> agent_host_;
 };
 
 static bool TimeComparator(const DevToolsTargetDescriptor* desc1,
                            const DevToolsTargetDescriptor* desc2) {
-  return desc1->GetAgentHost()->GetLastActivityTime() >
-         desc2->GetAgentHost()->GetLastActivityTime();
+  return desc1->GetLastActivityTime() > desc2->GetLastActivityTime();
 }
 
 // DevToolsHttpHandler::ServerSocketFactory ----------------------------------
 
 std::unique_ptr<net::ServerSocket>
 DevToolsHttpHandler::ServerSocketFactory::CreateForHttpServer() {
   return nullptr;
 }
 
 std::unique_ptr<net::ServerSocket>
@@ skipping 240 matching lines @@
 
   if (command == "list") {
     std::string host = info.headers["host"];
     DevToolsTargetDescriptor::List descriptors =
         devtools_discovery::DevToolsDiscoveryManager::GetInstance()->
             GetDescriptors();
     std::sort(descriptors.begin(), descriptors.end(), TimeComparator);
     base::STLDeleteValues(&descriptor_map_);
     base::ListValue list_value;
     for (DevToolsTargetDescriptor* descriptor : descriptors) {
-      descriptor_map_[descriptor->GetAgentHost()->GetId()] = descriptor;
+      descriptor_map_[descriptor->GetId()] = descriptor;
       list_value.Append(SerializeDescriptor(*descriptor, host));
     }
     SendJson(connection_id, net::HTTP_OK, &list_value, std::string());
     return;
   }
 
   if (command == "new") {
     GURL url(net::UnescapeURLComponent(
         query, net::UnescapeRule::URL_SPECIAL_CHARS_EXCEPT_PATH_SEPARATORS |
                    net::UnescapeRule::PATH_SEPARATORS));
     if (!url.is_valid())
       url = GURL(url::kAboutBlankURL);
     std::unique_ptr<DevToolsTargetDescriptor> descriptor =
         devtools_discovery::DevToolsDiscoveryManager::GetInstance()->CreateNew(
             url);
     if (!descriptor) {
       SendJson(connection_id,
                net::HTTP_INTERNAL_SERVER_ERROR,
                NULL,
                "Could not create new page");
       return;
     }
     std::string host = info.headers["host"];
     std::unique_ptr<base::DictionaryValue> dictionary(
         SerializeDescriptor(*descriptor.get(), host));
     SendJson(connection_id, net::HTTP_OK, dictionary.get(), std::string());
-    const std::string target_id = descriptor->GetAgentHost()->GetId();
+    const std::string target_id = descriptor->GetId();
     descriptor_map_[target_id] = descriptor.release();
     return;
   }
 
   if (command == "activate" || command == "close") {
     DevToolsTargetDescriptor* descriptor = GetDescriptor(target_id);
     if (!descriptor) {
       SendJson(connection_id,
                net::HTTP_NOT_FOUND,
                NULL,
                "No such target id: " + target_id);
       return;
     }
 
     if (command == "activate") {
-      if (descriptor->GetAgentHost()->Activate()) {
+      if (descriptor->Activate()) {
         SendJson(connection_id, net::HTTP_OK, NULL, "Target activated");
       } else {
         SendJson(connection_id,
                  net::HTTP_INTERNAL_SERVER_ERROR,
                  NULL,
                  "Could not activate target id: " + target_id);
       }
       return;
     }
 
     if (command == "close") {
-      if (descriptor->GetAgentHost()->Close()) {
+      if (descriptor->Close()) {
         SendJson(connection_id, net::HTTP_OK, NULL, "Target is closing");
       } else {
         SendJson(connection_id,
                  net::HTTP_INTERNAL_SERVER_ERROR,
                  NULL,
                  "Could not close target id: " + target_id);
       }
       return;
     }
   }
@@ skipping 10 matching lines @@
   if (it == descriptor_map_.end())
     return nullptr;
   return it->second;
 }
 
 void DevToolsHttpHandler::OnThumbnailRequest(
     int connection_id, const std::string& target_id) {
   DevToolsTargetDescriptor* descriptor = GetDescriptor(target_id);
   GURL page_url;
   if (descriptor)
-    page_url = descriptor->GetAgentHost()->GetURL();
+    page_url = descriptor->GetURL();
   std::string data = delegate_->GetPageThumbnailData(page_url);
   if (!data.empty())
     Send200(connection_id, data, "image/png");
   else
     Send404(connection_id);
 }
 
 void DevToolsHttpHandler::OnDiscoveryPageRequest(int connection_id) {
   std::string response = delegate_->GetDiscoveryPageHTML();
   Send200(connection_id, response, "text/html; charset=UTF-8");
@@ skipping 207 matching lines @@
   thread_->task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&ServerWrapper::AcceptWebSocket,
                  base::Unretained(server_wrapper_), connection_id, request));
 }
 
 base::DictionaryValue* DevToolsHttpHandler::SerializeDescriptor(
     const DevToolsTargetDescriptor& descriptor,
     const std::string& host) {
   base::DictionaryValue* dictionary = new base::DictionaryValue;
-  scoped_refptr<content::DevToolsAgentHost> agent_host =
-      descriptor.GetAgentHost();
-  std::string id = agent_host->GetId();
+
+  std::string id = descriptor.GetId();
   dictionary->SetString(kTargetIdField, id);
-  std::string parent_id = agent_host->GetParentId();
+  std::string parent_id = descriptor.GetParentId();
   if (!parent_id.empty())
     dictionary->SetString(kTargetParentIdField, parent_id);
-  dictionary->SetString(kTargetTypeField, agent_host->GetType());
+  dictionary->SetString(kTargetTypeField, descriptor.GetType());
   dictionary->SetString(kTargetTitleField,
-                        net::EscapeForHTML(agent_host->GetTitle()));
-  dictionary->SetString(kTargetDescriptionField, agent_host->GetDescription());
+                        net::EscapeForHTML(descriptor.GetTitle()));
+  dictionary->SetString(kTargetDescriptionField, descriptor.GetDescription());
 
-  GURL url = agent_host->GetURL();
+  GURL url = descriptor.GetURL();
   dictionary->SetString(kTargetUrlField, url.spec());
 
-  GURL favicon_url = agent_host->GetFaviconURL();
+  GURL favicon_url = descriptor.GetFaviconURL();
   if (favicon_url.is_valid())
     dictionary->SetString(kTargetFaviconUrlField, favicon_url.spec());
 
   if (!delegate_->GetPageThumbnailData(url).empty()) {
     dictionary->SetString(kTargetThumbnailUrlField,
                           std::string(kThumbUrlPrefix) + id);
   }
 
-  if (!agent_host->IsAttached()) {
+  if (!descriptor.IsAttached()) {
     dictionary->SetString(kTargetWebSocketDebuggerUrlField,
                           base::StringPrintf("ws://%s%s%s",
                                              host.c_str(),
                                              kPageUrlPrefix,
                                              id.c_str()));
     std::string devtools_frontend_url = GetFrontendURLInternal(
         id.c_str(),
         host);
     dictionary->SetString(
         kTargetDevtoolsFrontendUrlField, devtools_frontend_url);
   }
 
   return dictionary;
 }
 
 }  // namespace devtools_http_handler