DevTools: fix memory issue with layout test

content/shell/browser/layout_test/blink_test_controller.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 "content/shell/browser/layout_test/blink_test_controller.h"
 
 #include <stddef.h>
 
 #include <iostream>
 #include <set>
@@ skipping 229 matching lines @@
 BlinkTestController* BlinkTestController::instance_ = NULL;
 
 // static
 BlinkTestController* BlinkTestController::Get() {
   DCHECK(instance_);
   return instance_;
 }
 
 BlinkTestController::BlinkTestController()
     : main_window_(NULL),
+      devtools_window_(nullptr),
       test_phase_(BETWEEN_TESTS),
       is_leak_detection_enabled_(
           base::CommandLine::ForCurrentProcess()->HasSwitch(
               switches::kEnableLeakDetection)),
       crash_when_leak_found_(false),
       render_process_host_observer_(this) {
   CHECK(!instance_);
   instance_ = this;
 
   if (is_leak_detection_enabled_) {
@@ skipping 247 matching lines @@
 void BlinkTestController::RenderFrameCreated(
     RenderFrameHost* render_frame_host) {
   DCHECK(CalledOnValidThread());
   HandleNewRenderFrameHost(render_frame_host);
 }
 
 void BlinkTestController::DevToolsProcessCrashed() {
   DCHECK(CalledOnValidThread());
   printer_->AddErrorMessage("#CRASHED - devtools");
   devtools_bindings_.reset();
-  devtools_window_.reset();
+  if (devtools_window_)
+    devtools_window_->Close();
+  devtools_window_ = nullptr;
 }
 
 void BlinkTestController::WebContentsDestroyed() {
   DCHECK(CalledOnValidThread());
   printer_->AddErrorMessage("FAIL: main window was destroyed");
   DiscardMainWindow();
 }
 
 void BlinkTestController::RenderProcessHostDestroyed(
     RenderProcessHost* render_process_host) {
@@ skipping 299 matching lines @@
   storage_partition->GetDOMStorageContext()->DeleteLocalStorage(
       content::LayoutTestDevToolsBindings::GetDevToolsPathAsURL("")
           .GetOrigin());
 }
 
 void BlinkTestController::OnShowDevTools(const std::string& settings,
                                          const std::string& frontend_url) {
   if (!devtools_window_) {
     ShellBrowserContext* browser_context =
         ShellContentBrowserClient::Get()->browser_context();
-    devtools_window_.reset(content::Shell::CreateNewWindow(
-        browser_context, GURL(), nullptr, initial_size_));
+    devtools_window_ = content::Shell::CreateNewWindow(browser_context, GURL(),
+                                                       nullptr, initial_size_);
   }
 
   devtools_bindings_.reset(LayoutTestDevToolsBindings::LoadDevTools(
       devtools_window_->web_contents(), main_window_->web_contents(), settings,
       frontend_url));
   devtools_window_->web_contents()->GetRenderViewHost()->GetWidget()->Focus();
   devtools_window_->web_contents()->Focus();
 }
 
 void BlinkTestController::OnEvaluateInDevTools(
@@ skipping 58 matching lines @@
   Send(new ShellViewMsg_SessionHistory(render_view_host->GetRoutingID(),
                                        routing_ids,
                                        session_histories,
                                        current_entry_indexes));
 }
 
 void BlinkTestController::OnCloseRemainingWindows() {
   DevToolsAgentHost::DetachAllClients();
   std::vector<Shell*> open_windows(Shell::windows());
   for (size_t i = 0; i < open_windows.size(); ++i) {
-    if (open_windows[i] != main_window_ &&
-        open_windows[i] != devtools_window_.get())
+    if (open_windows[i] != main_window_ && open_windows[i] != devtools_window_)
       open_windows[i]->Close();
   }
   base::RunLoop().RunUntilIdle();
 }
 
 void BlinkTestController::OnResetDone() {
   if (is_leak_detection_enabled_) {
     if (main_window_ && main_window_->web_contents()) {
       RenderViewHost* render_view_host =
           main_window_->web_contents()->GetRenderViewHost();
@@ skipping 78 matching lines @@
   }
   DCHECK(layout_test_control_map_[frame].get());
   return layout_test_control_map_[frame].get();
 }
 
 void BlinkTestController::HandleLayoutTestControlError(RenderFrameHost* frame) {
   layout_test_control_map_.erase(frame);
 }
 
 }  // namespace content