Add commands to manage tabs and contexts to Browser Domain

headless/lib/browser/headless_browser_impl.cc

 // Copyright 2015 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 "headless/lib/browser/headless_browser_impl.h"
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
@@ skipping 47 matching lines @@
   DCHECK(BrowserMainThread()->BelongsToCurrentThread());
   return HeadlessWebContents::Builder(this);
 }
 
 HeadlessBrowserContext::Builder
 HeadlessBrowserImpl::CreateBrowserContextBuilder() {
   DCHECK(BrowserMainThread()->BelongsToCurrentThread());
   return HeadlessBrowserContext::Builder(this);
 }
 
+void HeadlessBrowserImpl::AddObserver(Observer* observer) {
+  observers_.insert(observer);
+}
+
+void HeadlessBrowserImpl::RemoveObserver(Observer* observer) {
+  observers_.erase(observer);
+}
+
 HeadlessWebContents* HeadlessBrowserImpl::CreateWebContents(
     HeadlessWebContents::Builder* builder) {
   DCHECK(BrowserMainThread()->BelongsToCurrentThread());
   std::unique_ptr<HeadlessWebContentsImpl> headless_web_contents =
       HeadlessWebContentsImpl::Create(builder, window_tree_host_->window(),
                                       this);
   if (!headless_web_contents)
     return nullptr;
   return RegisterWebContents(std::move(headless_web_contents));
 }
@@ skipping 23 matching lines @@
   DCHECK(BrowserMainThread()->BelongsToCurrentThread());
   BrowserMainThread()->PostTask(FROM_HERE,
                                 base::MessageLoop::QuitWhenIdleClosure());
 }
 
 std::vector<HeadlessWebContents*> HeadlessBrowserImpl::GetAllWebContents() {
   std::vector<HeadlessWebContents*> result;
   result.reserve(web_contents_.size());
 
   for (const auto& web_contents_pair : web_contents_) {
-    result.push_back(web_contents_pair.first);
+    result.push_back(web_contents_pair.second.get());
   }
 
   return result;
 }
 
 HeadlessBrowserMainParts* HeadlessBrowserImpl::browser_main_parts() const {
   DCHECK(BrowserMainThread()->BelongsToCurrentThread());
   return browser_main_parts_;
 }
 
@@ skipping 13 matching lines @@
 
   window_tree_client_.reset(
       new HeadlessWindowTreeClient(window_tree_host_->window()));
 
   on_start_callback_.Run(this);
   on_start_callback_ = base::Callback<void(HeadlessBrowser*)>();
 }
 
 HeadlessWebContentsImpl* HeadlessBrowserImpl::RegisterWebContents(
     std::unique_ptr<HeadlessWebContentsImpl> web_contents) {
+  DCHECK(BrowserMainThread()->BelongsToCurrentThread());
   DCHECK(web_contents);
   HeadlessWebContentsImpl* unowned_web_contents = web_contents.get();
   web_contents_[unowned_web_contents] = std::move(web_contents);
+  for (auto it = observers_.begin(); it != observers_.end();) {
+    // Pre-increment it because the observer may unregister itself.
+    Observer* observer = *it++;
+    observer->HeadlessWebContentsCreated(unowned_web_contents);
+  }
   return unowned_web_contents;
 }
 
 void HeadlessBrowserImpl::DestroyWebContents(
     HeadlessWebContentsImpl* web_contents) {
-  auto it = web_contents_.find(web_contents);
-  DCHECK(it != web_contents_.end());
-  web_contents_.erase(it);
+  DCHECK(BrowserMainThread()->BelongsToCurrentThread());
+  auto find_it = web_contents_.find(web_contents);
+  DCHECK(find_it != web_contents_.end());
+  HeadlessWebContents* headless_web_contents = find_it->second.get();
+  web_contents_.erase(find_it);
+  for (auto it = observers_.begin(); it != observers_.end();) {
+    // Pre-increment it because the observer may unregister itself.
+    Observer* observer = *it++;
+    observer->HeadlessWebContentsDestroyed(headless_web_contents);
+  }
 }
 
 void HeadlessBrowserImpl::SetOptionsForTesting(
     HeadlessBrowser::Options options) {
   options_ = std::move(options);
   browser_main_parts()->default_browser_context()->SetOptionsForTesting(
       &options_);
 }
 
 void RunChildProcessIfNeeded(int argc, const char** argv) {
@@ skipping 18 matching lines @@
 
   // Child processes should not end up here.
   base::CommandLine command_line(options.argc, options.argv);
   DCHECK(!command_line.HasSwitch(switches::kProcessType));
 #endif
   return RunContentMain(std::move(options),
                         std::move(on_browser_start_callback));
 }
 
 }  // namespace headless