Only do aggressive metro viewer termination in tests

win8/viewer/metro_viewer_process_host.cc

 // Copyright (c) 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 "win8/viewer/metro_viewer_process_host.h"
 
 #include <shlobj.h>
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
@@ skipping 29 matching lines @@
     MetroViewerProcessHost* owner)
     : owner_(owner) {
 }
 
 void MetroViewerProcessHost::InternalMessageFilter::OnChannelConnected(
     int32 peer_pid) {
   owner_->NotifyChannelConnected();
 }
 
 MetroViewerProcessHost::MetroViewerProcessHost(
-    base::SingleThreadTaskRunner* ipc_task_runner) {
+    base::SingleThreadTaskRunner* ipc_task_runner)
+    : launched_for_test_(false) {
   DCHECK(!instance_);
   instance_ = this;
 
   channel_ = IPC::ChannelProxy::Create(kMetroViewerIPCChannelName,
                                        IPC::Channel::MODE_NAMED_SERVER,
                                        this,
                                        ipc_task_runner);
 }
 
 MetroViewerProcessHost::~MetroViewerProcessHost() {
   if (!channel_) {
     instance_ = NULL;
     return;
   }
 
   base::ProcessId viewer_process_id = GetViewerProcessId();
   channel_->Close();
   if (message_filter_) {
     // Wait for the viewer process to go away.
     if (viewer_process_id != base::kNullProcessId) {
       base::ProcessHandle viewer_process = NULL;
       base::OpenProcessHandleWithAccess(
           viewer_process_id,
           PROCESS_QUERY_INFORMATION | SYNCHRONIZE,
           &viewer_process);
       if (viewer_process) {
-        ::WaitForSingleObject(viewer_process, INFINITE);
+        if (launched_for_test_) {
+          // In tests, we don't want to wait around for the viewer to
+          // terminate, so kill it after a short delay. See
+          // http://crbug.com/411147 for more details.
+          ::WaitForSingleObject(viewer_process, 100);

[ananta, 2014/09/19 19:36:57]

Just TerminateProcess here?. The viewer has no state. In any case the Wait is
flaky as we have been seeing.

[scottmg, 2014/09/19 19:41:19]

Sure, Done.

+          ::TerminateProcess(viewer_process, 0);
+        } else {
+          ::WaitForSingleObject(viewer_process, INFINITE);
+        }
         ::CloseHandle(viewer_process);
       }
     }
     channel_->RemoveFilter(message_filter_);
   }
   instance_ = NULL;
 }
 
 base::ProcessId MetroViewerProcessHost::GetViewerProcessId() {
   if (channel_)
     return channel_->GetPeerPID();
   return base::kNullProcessId;
 }
 
+bool MetroViewerProcessHost::LaunchViewerAndWaitForConnectionForTests(
+    const base::string16& app_user_model_id) {
+  launched_for_test_ = true;
+  return LaunchViewerAndWaitForConnection(app_user_model_id);
+}
+
 bool MetroViewerProcessHost::LaunchViewerAndWaitForConnection(
     const base::string16& app_user_model_id) {
   DCHECK_EQ(base::kNullProcessId, channel_->GetPeerPID());
 
   channel_connected_event_.reset(new base::WaitableEvent(false, false));
 
   message_filter_ = new InternalMessageFilter(this);
   channel_->AddFilter(message_filter_);
 
   if (base::win::GetVersion() >= base::win::VERSION_WIN8) {
@@ skipping 233 matching lines @@
     const base::FilePath& folder) {
   if (success)
     select_folder_completion_callback_.Run(base::FilePath(folder), 0, NULL);
   else
     failure_callback_.Run(NULL);
   select_folder_completion_callback_.Reset();
   failure_callback_.Reset();
 }
 
 }  // namespace win8