Introduce SerializeDictionaryForest for devtools_target_ui

chrome/browser/devtools/devtools_targets_ui.cc

 // Copyright 2013 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/devtools/devtools_targets_ui.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "base/version.h"
 #include "chrome/browser/devtools/device/devtools_android_bridge.h"
+#include "chrome/browser/devtools/serialize_host_descriptions.h"
 #include "content/public/browser/browser_child_process_observer.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/child_process_data.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/worker_service.h"
@@ skipping 195 matching lines @@
                      base::Unretained(this)),
           base::TimeDelta::FromMilliseconds(kUpdateDelay)));
 }
 
 void LocalTargetsUIHandler::UpdateTargets() {
   SendTargets(DevToolsAgentHost::GetOrCreateAll());
 }
 
 void LocalTargetsUIHandler::SendTargets(
     const content::DevToolsAgentHost::List& targets) {
-  base::ListValue list_value;
-  std::map<std::string, base::DictionaryValue*> id_to_descriptor;
+  std::vector<HostDescriptionNode> hosts;
+  hosts.reserve(targets.size());
 
   targets_.clear();
-  for (scoped_refptr<DevToolsAgentHost> host : targets) {
+  for (const scoped_refptr<DevToolsAgentHost>& host : targets) {
     targets_[host->GetId()] = host;
-    id_to_descriptor[host->GetId()] = Serialize(host).release();
+    hosts.push_back(
+        {host->GetId(), host->GetParentId(), *Serialize(host.get())});
   }
 
-  for (auto& it : targets_) {
-    scoped_refptr<DevToolsAgentHost> host = it.second;
-    base::DictionaryValue* descriptor = id_to_descriptor[host->GetId()];
-    DCHECK(descriptor);
-    std::string parent_id = host->GetParentId();
-    if (parent_id.empty() || id_to_descriptor.count(parent_id) == 0) {
-      list_value.Append(base::WrapUnique(descriptor));
-    } else {
-      base::DictionaryValue* parent = id_to_descriptor[parent_id];
-      base::ListValue* guests_weak = NULL;
-      if (!parent->GetList(kGuestList, &guests_weak)) {
-        auto guests = base::MakeUnique<base::ListValue>();
-        guests_weak = guests.get();
-        parent->Set(kGuestList, std::move(guests));
-      }
-      guests_weak->Append(base::WrapUnique(descriptor));
-    }
-  }
-
-  SendSerializedTargets(list_value);
+  SendSerializedTargets(
+      SerializeHostDescriptions(std::move(hosts), kGuestList));
 }
 
 // AdbTargetsUIHandler --------------------------------------------------------
 
 class AdbTargetsUIHandler
     : public DevToolsTargetsUIHandler,
       public DevToolsAndroidBridge::DeviceListListener {
  public:
   AdbTargetsUIHandler(const Callback& callback, Profile* profile);
   ~AdbTargetsUIHandler() override;
@@ skipping 87 matching lines @@
           kAdbBrowserChromeVersionField,
           browser->IsChrome() && !parsed.empty() ? parsed[0] : 0);
       std::string browser_id = browser->GetId();
       browser_data->SetString(kTargetIdField, browser_id);
       browser_data->SetString(kTargetSourceField, source_id());
 
       auto page_list = base::MakeUnique<base::ListValue>();
       remote_browsers_[browser_id] = browser;
       for (const auto& page : browser->pages()) {
         scoped_refptr<DevToolsAgentHost> host = page->CreateTarget();
-        std::unique_ptr<base::DictionaryValue> target_data = Serialize(host);
+        std::unique_ptr<base::DictionaryValue> target_data =
+            Serialize(host.get());
         // Pass the screen size in the target object to make sure that
         // the caching logic does not prevent the target item from updating
         // when the screen size changes.
         gfx::Size screen_size = device->screen_size();
         target_data->SetInteger(kAdbScreenWidthField, screen_size.width());
         target_data->SetInteger(kAdbScreenHeightField, screen_size.height());
         targets_[host->GetId()] = host;
         page_list->Append(std::move(target_data));
       }
       browser_data->Set(kAdbPagesList, std::move(page_list));
@@ skipping 48 matching lines @@
 void DevToolsTargetsUIHandler::Open(const std::string& browser_id,
                                     const std::string& url) {
 }
 
 scoped_refptr<DevToolsAgentHost>
 DevToolsTargetsUIHandler::GetBrowserAgentHost(const std::string& browser_id) {
   return NULL;
 }
 
 std::unique_ptr<base::DictionaryValue> DevToolsTargetsUIHandler::Serialize(
-    scoped_refptr<DevToolsAgentHost> host) {
+    DevToolsAgentHost* host) {
   auto target_data = base::MakeUnique<base::DictionaryValue>();
   target_data->SetString(kTargetSourceField, source_id_);
   target_data->SetString(kTargetIdField, host->GetId());
   target_data->SetString(kTargetTypeField, host->GetType());
   target_data->SetBoolean(kAttachedField, host->IsAttached());
   target_data->SetString(kUrlField, host->GetURL().spec());
   target_data->SetString(kNameField, host->GetTitle());
   target_data->SetString(kFaviconUrlField, host->GetFaviconURL().spec());
   target_data->SetString(kDescriptionField, host->GetDescription());
   return target_data;
@@ skipping 43 matching lines @@
     device_status_dict->SetString(kPortForwardingBrowserId,
                                   sit->first->GetId());
 
     std::string device_id = base::StringPrintf(
         kAdbDeviceIdFormat,
         sit->first->serial().c_str());
     result.Set(device_id, std::move(device_status_dict));
   }
   callback_.Run(result);
 }