Improving flat containers interface.

content/browser/devtools/protocol/target_auto_attacher.cc

 // Copyright 2017 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/protocol/target_auto_attacher.h"
 
 #include "content/browser/devtools/render_frame_devtools_agent_host.h"
 #include "content/browser/devtools/service_worker_devtools_agent_host.h"
 #include "content/browser/frame_host/frame_tree.h"
 #include "content/browser/frame_host/frame_tree_node.h"
@@ skipping 116 matching lines @@
           queue.push(node->child_at(i));
       }
     }
   }
 
   // TODO(dgozman): support wait_for_debugger_on_start_.
   ReattachTargetsOfType(new_hosts, DevToolsAgentHost::kTypeFrame, false);
 }
 
 void TargetAutoAttacher::AgentHostClosed(DevToolsAgentHost* host) {
-  auto_attached_hosts_.erase(host);
+  auto_attached_hosts_.erase(make_scoped_refptr(host));

[danakj, 2017/07/20 15:52:52]

Not for this CL but looks like we should make a comparator for scoped_refptr
keys, and use it for all applicable flat set/maps, so we don't have to do this.

[dyaroshev, 2017/07/20 16:03:18]

I agree. We discussed that earlier in this CL, I even had a general purpose
solution in earlier version of this CL.

 }
 
 void TargetAutoAttacher::ReattachServiceWorkers(bool waiting_for_debugger) {
   if (!auto_attach_)
     return;
 
   frame_urls_.clear();
   BrowserContext* browser_context = nullptr;
   if (render_frame_host_) {
     // TODO(dgozman): do not traverse inside cross-process subframes.
@@ skipping 10 matching lines @@
     if (pair.second->IsReadyForInspection())
       new_hosts.insert(pair.second);
   }
   ReattachTargetsOfType(new_hosts, DevToolsAgentHost::kTypeServiceWorker,
                         waiting_for_debugger);
 }
 
 void TargetAutoAttacher::ReattachTargetsOfType(const Hosts& new_hosts,
                                                const std::string& type,
                                                bool waiting_for_debugger) {
-  Hosts old_hosts = auto_attached_hosts_;
-  for (auto& it : old_hosts) {
-    DevToolsAgentHost* host = it.get();
-    if (host->GetType() == type && new_hosts.find(host) == new_hosts.end()) {
-      auto_attached_hosts_.erase(host);
-      detach_callback_.Run(host);
-    }
+  // Detach.
+  {
+    Hosts removed_hosts =
+        base::STLSetDifference<Hosts>(new_hosts, auto_attached_hosts_);
+    for (const auto& h : removed_hosts)

[dyaroshev, 2017/07/19 23:38:41]

And I missed GetType check. Ok than, I'll revert this and just fix the
compilation.

[danakj, 2017/07/20 15:52:52]

I'll wait for your update then.

+      detach_callback_.Run(h.get());
   }
-  for (auto& it : new_hosts) {
-    DevToolsAgentHost* host = it.get();
-    if (old_hosts.find(host) == old_hosts.end()) {
-      if (attach_callback_.Run(host, waiting_for_debugger))
-        auto_attached_hosts_.insert(host);
-    }
+
+  // Attach.
+  {
+    Hosts newly_attached_hosts =
+        base::STLSetDifference<Hosts>(auto_attached_hosts_, new_hosts);
+
+    auto_attached_hosts_.clear();
+
+    // Since newly_attached is already a set, inserting in the end is faster
+    // than buffer + sort.
+    std::copy_if(
+        newly_attached_hosts.begin(), newly_attached_hosts.end(),
+        std::inserter(auto_attached_hosts_, auto_attached_hosts_.end()),
+        [&](const scoped_refptr<DevToolsAgentHost>& h) {
+          return attach_callback_.Run(h.get(), waiting_for_debugger);
+        });
   }
 }
 
 void TargetAutoAttacher::SetAutoAttach(bool auto_attach,
                                        bool wait_for_debugger_on_start) {
   wait_for_debugger_on_start_ = wait_for_debugger_on_start;
   if (auto_attach_ == auto_attach)
     return;
   auto_attach_ = auto_attach;
   if (auto_attach_) {
@@ skipping 55 matching lines @@
     ServiceWorkerDevToolsAgentHost* host) {
   ReattachServiceWorkers(false);
 }
 
 void TargetAutoAttacher::WorkerDestroyed(ServiceWorkerDevToolsAgentHost* host) {
   ReattachServiceWorkers(false);
 }
 
 }  // namespace protocol
 }  // namespace content