Remove base/win/metro.{cc|h} and some associated code

chrome/browser/process_singleton_win.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 "chrome/browser/process_singleton.h"
 
 #include <shellapi.h>
 #include <stddef.h>
 
 #include "base/base_paths.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/process/process.h"
 #include "base/process/process_info.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
-#include "base/win/metro.h"
 #include "base/win/registry.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/windows_version.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_process_platform_part.h"
 #include "chrome/browser/chrome_process_finder_win.h"
-#include "chrome/browser/metro_utils/metro_chrome_win.h"
 #include "chrome/browser/shell_integration.h"
 #include "chrome/browser/ui/simple_message_box.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_paths_internal.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/grit/chromium_strings.h"
 #include "chrome/installer/util/wmi.h"
 #include "content/public/common/result_codes.h"
 #include "net/base/escape.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/win/hwnd_util.h"
 
 namespace {
 
 const char kLockfile[] = "lockfile";
 
-const int kMetroChromeActivationTimeoutMs = 3000;
-
 // A helper class that acquires the given |mutex| while the AutoLockMutex is in
 // scope.
 class AutoLockMutex {
  public:
   explicit AutoLockMutex(HANDLE mutex) : mutex_(mutex) {
     DWORD result = ::WaitForSingleObject(mutex_, INFINITE);
     DPCHECK(result == WAIT_OBJECT_0) << "Result = " << result;
   }
 
   ~AutoLockMutex() {
@@ skipping 253 matching lines @@
         *base::CommandLine::ForCurrentProcess());
   }
   return result;
 }
 
 // Look for a Chrome instance that uses the same profile directory. If there
 // isn't one, create a message window with its title set to the profile
 // directory path.
 bool ProcessSingleton::Create() {
   static const wchar_t kMutexName[] = L"Local\\ChromeProcessSingletonStartup!";
-  static const wchar_t kMetroActivationEventName[] =
-      L"Local\\ChromeProcessSingletonStartupMetroActivation!";
 
   remote_window_ = chrome::FindRunningChromeWindow(user_data_dir_);
   if (!remote_window_ && !EscapeVirtualization(user_data_dir_)) {
     // Make sure we will be the one and only process creating the window.
     // We use a named Mutex since we are protecting against multi-process
     // access. As documented, it's clearer to NOT request ownership on creation
     // since it isn't guaranteed we will get it. It is better to create it
     // without ownership and explicitly get the ownership afterward.
     base::win::ScopedHandle only_me(::CreateMutex(NULL, FALSE, kMutexName));
     if (!only_me.IsValid()) {
       DPLOG(FATAL) << "CreateMutex failed";
       return false;
     }
 
     AutoLockMutex auto_lock_only_me(only_me.Get());
 
     // We now own the mutex so we are the only process that can create the
     // window at this time, but we must still check if someone created it
     // between the time where we looked for it above and the time the mutex
     // was given to us.
     remote_window_ = chrome::FindRunningChromeWindow(user_data_dir_);
 
-
-    // In Win8+, a new Chrome process launched in Desktop mode may need to be
-    // transmuted into Metro Chrome (see ShouldLaunchInWindows8ImmersiveMode for
-    // heuristics). To accomplish this, the current Chrome activates Metro
-    // Chrome, releases the startup mutex, and waits for metro Chrome to take
-    // the singleton. From that point onward, the command line for this Chrome
-    // process will be sent to Metro Chrome by the usual channels.
-    if (!remote_window_ && base::win::GetVersion() >= base::win::VERSION_WIN8 &&
-        !base::win::IsMetroProcess()) {
-      // |metro_activation_event| is created right before activating a Metro
-      // Chrome (note that there can only be one Metro Chrome process; by OS
-      // design); all following Desktop processes will then wait for this event
-      // to be signaled by Metro Chrome which will do so as soon as it grabs
-      // this singleton (should any of the waiting processes timeout waiting for
-      // the signal they will try to grab the singleton for themselves which
-      // will result in a forced Desktop Chrome launch in the worst case).
-      base::win::ScopedHandle metro_activation_event(
-          ::OpenEvent(SYNCHRONIZE, FALSE, kMetroActivationEventName));
-      if (!metro_activation_event.IsValid() &&
-          ShouldLaunchInWindows8ImmersiveMode(user_data_dir_)) {
-        // No Metro activation is under way, but the desire is to launch in
-        // Metro mode: activate and rendez-vous with the activated process.
-        metro_activation_event.Set(
-            ::CreateEvent(NULL, TRUE, FALSE, kMetroActivationEventName));
-        if (!chrome::ActivateMetroChrome()) {
-          // Failed to launch immersive Chrome, default to launching on Desktop.
-          LOG(ERROR) << "Failed to launch immersive chrome";
-          metro_activation_event.Close();
-        }
-      }
-
-      if (metro_activation_event.IsValid()) {
-        // Release |only_me| (to let Metro Chrome grab this singleton) and wait
-        // until the event is signaled (i.e. Metro Chrome was successfully
-        // activated). Ignore timeout waiting for |metro_activation_event|.
-        {
-          AutoUnlockMutex auto_unlock_only_me(only_me.Get());
-
-          DWORD result = ::WaitForSingleObject(metro_activation_event.Get(),
-                                               kMetroChromeActivationTimeoutMs);
-          DPCHECK(result == WAIT_OBJECT_0 || result == WAIT_TIMEOUT)
-              << "Result = " << result;
-        }
-
-        // Check if this singleton was successfully grabbed by another process
-        // (hopefully Metro Chrome). Failing to do so, this process will grab
-        // the singleton and launch in Desktop mode.
-        remote_window_ = chrome::FindRunningChromeWindow(user_data_dir_);
-      }
-    }
-
     if (!remote_window_) {
       // We have to make sure there is no Chrome instance running on another
       // machine that uses the same profile.
       base::FilePath lock_file_path = user_data_dir_.AppendASCII(kLockfile);
       lock_file_ = ::CreateFile(lock_file_path.value().c_str(),
                                 GENERIC_WRITE,
                                 FILE_SHARE_READ,
                                 NULL,
                                 CREATE_ALWAYS,
                                 FILE_ATTRIBUTE_NORMAL |
                                 FILE_FLAG_DELETE_ON_CLOSE,
                                 NULL);
       DWORD error = ::GetLastError();
       LOG_IF(WARNING, lock_file_ != INVALID_HANDLE_VALUE &&
           error == ERROR_ALREADY_EXISTS) << "Lock file exists but is writable.";
       LOG_IF(ERROR, lock_file_ == INVALID_HANDLE_VALUE)
           << "Lock file can not be created! Error code: " << error;
 
       if (lock_file_ != INVALID_HANDLE_VALUE) {
         // Set the window's title to the path of our user data directory so
         // other Chrome instances can decide if they should forward to us.
         bool result = window_.CreateNamed(
             base::Bind(&ProcessLaunchNotification, notification_callback_),
             user_data_dir_.value());
         CHECK(result && window_.hwnd());
       }
-
-      if (base::win::GetVersion() >= base::win::VERSION_WIN8) {
-        // Make sure no one is still waiting on Metro activation whether it
-        // succeeded (i.e., this is the Metro process) or failed.
-        base::win::ScopedHandle metro_activation_event(
-            ::OpenEvent(EVENT_MODIFY_STATE, FALSE, kMetroActivationEventName));
-        if (metro_activation_event.IsValid())
-          ::SetEvent(metro_activation_event.Get());
-      }
     }
   }
 
   return window_.hwnd() != NULL;
 }
 
 void ProcessSingleton::Cleanup() {
 }
 
 void ProcessSingleton::OverrideShouldKillRemoteProcessCallbackForTesting(
     const ShouldKillRemoteProcessCallback& display_dialog_callback) {
   should_kill_remote_process_callback_ = display_dialog_callback;
 }