[content shell] don't open new windows after printing the test results

content/shell/webkit_test_controller.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 "content/shell/webkit_test_controller.h"
 
 #include <iostream>
 
 #include "base/command_line.h"
 #include "base/message_loop.h"
@@ skipping 153 matching lines @@
 WebKitTestController* WebKitTestController::instance_ = NULL;
 
 // static
 WebKitTestController* WebKitTestController::Get() {
   DCHECK(instance_);
   return instance_;
 }
 
 WebKitTestController::WebKitTestController()
     : main_window_(NULL),
-      is_running_test_(false) {
+      test_phase_(BETWEEN_TESTS) {
   CHECK(!instance_);
   instance_ = this;
   printer_.reset(new WebKitTestResultPrinter(&std::cout, &std::cerr));
   registrar_.Add(this,
                  NOTIFICATION_RENDERER_PROCESS_CREATED,
                  NotificationService::AllSources());
   GpuDataManager::GetInstance()->AddObserver(this);
   ResetAfterLayoutTest();
 }
 
 WebKitTestController::~WebKitTestController() {
   DCHECK(CalledOnValidThread());
   CHECK(instance_ == this);
-  CHECK(!is_running_test_);
+  CHECK(test_phase_ == BETWEEN_TESTS);
   GpuDataManager::GetInstance()->RemoveObserver(this);
   DiscardMainWindow();
   instance_ = NULL;
 }
 
 bool WebKitTestController::PrepareForLayoutTest(
     const GURL& test_url,
     const base::FilePath& current_working_directory,
     bool enable_pixel_dumping,
     const std::string& expected_pixel_hash) {
   DCHECK(CalledOnValidThread());
-  is_running_test_ = true;
+  test_phase_ = DURING_TEST;
   current_working_directory_ = current_working_directory;
   enable_pixel_dumping_ = enable_pixel_dumping;
   expected_pixel_hash_ = expected_pixel_hash;
   test_url_ = test_url;
   printer_->reset();
   ShellBrowserContext* browser_context =
       ShellContentBrowserClient::Get()->browser_context();
   if (test_url.spec().find("compositing/") != std::string::npos)
     is_compositing_test_ = true;
   initial_size_ = gfx::Size(
@@ skipping 45 matching lines @@
         base::TimeDelta::FromMilliseconds(kTestTimeoutMilliseconds + 1000));
   }
   return true;
 }
 
 bool WebKitTestController::ResetAfterLayoutTest() {
   DCHECK(CalledOnValidThread());
   printer_->PrintTextFooter();
   printer_->PrintImageFooter();
   send_configuration_to_next_host_ = false;
-  is_running_test_ = false;
+  test_phase_ = BETWEEN_TESTS;
   is_compositing_test_ = false;
   enable_pixel_dumping_ = false;
   expected_pixel_hash_.clear();
   test_url_ = GURL();
   prefs_ = WebPreferences();
   should_override_prefs_ = false;
   watchdog_.Cancel();
   return true;
 }
 
@@ skipping 15 matching lines @@
       CommandLine& command_line = *CommandLine::ForCurrentProcess();
       if (!command_line.HasSwitch(switches::kEnableSoftwareCompositing))
         prefs->accelerated_2d_canvas_enabled = true;
       prefs->accelerated_compositing_for_video_enabled = true;
       prefs->mock_scrollbars_enabled = true;
     }
   }
 }
 
 void WebKitTestController::OpenURL(const GURL& url) {
+  if (test_phase_ != DURING_TEST)
+    return;
+
   Shell::CreateNewWindow(main_window_->web_contents()->GetBrowserContext(),
                          url,
                          main_window_->web_contents()->GetSiteInstance(),
                          MSG_ROUTING_NONE,
                          gfx::Size());
 }
 
 void WebKitTestController::TestFinishedInSecondaryWindow() {
   RenderViewHost* render_view_host =
       main_window_->web_contents()->GetRenderViewHost();
@@ skipping 105 matching lines @@
   printer_->AddErrorMessage(
       "FAIL: Timed out waiting for notifyDone to be called");
   DiscardMainWindow();
 }
 
 void WebKitTestController::DiscardMainWindow() {
   // If we're running a test, we need to close all windows and exit the message
   // loop. Otherwise, we're already outside of the message loop, and we just
   // discard the main window.
   WebContentsObserver::Observe(NULL);
-  if (is_running_test_) {
+  if (test_phase_ != BETWEEN_TESTS) {
     Shell::CloseAllWindows();
     base::MessageLoop::current()->PostTask(FROM_HERE,
                                            base::MessageLoop::QuitClosure());
+    test_phase_ = CLEAN_UP;
   } else if (main_window_) {
     main_window_->Close();
   }
   main_window_ = NULL;
   current_pid_ = base::kNullProcessId;
 }
 
 void WebKitTestController::SendTestConfiguration() {
   RenderViewHost* render_view_host =
       main_window_->web_contents()->GetRenderViewHost();
@@ skipping 15 matching lines @@
 }
 
 void WebKitTestController::OnTestFinished(bool did_timeout) {
   watchdog_.Cancel();
   if (did_timeout) {
     printer_->AddErrorMessage(
         "FAIL: Timed out waiting for notifyDone to be called");
     DiscardMainWindow();
     return;
   }
+  test_phase_ = CLEAN_UP;
   if (!printer_->output_finished())
     printer_->PrintImageFooter();
   RenderViewHost* render_view_host =
       main_window_->web_contents()->GetRenderViewHost();
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(base::IgnoreResult(&WebKitTestController::Send),
                  base::Unretained(this),
                  new ShellViewMsg_Reset(render_view_host->GetRoutingID())));
 }
@@ skipping 138 matching lines @@
   }
   base::MessageLoop::current()->RunUntilIdle();
 }
 
 void WebKitTestController::OnResetDone() {
   base::MessageLoop::current()->PostTask(FROM_HERE,
                                          base::MessageLoop::QuitClosure());
 }
 
 }  // namespace content