Remove implicit HANDLE conversions from chrome.

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 "base/base_paths.h"
 #include "base/bind.h"
@@ skipping 338 matching lines @@
       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));
-    DPCHECK(only_me.IsValid());
+    if (!only_me.IsValid()) {
+      DPLOG(FATAL) << "CreateMutex failed";
+      return false;
+    }
 
-    AutoLockMutex auto_lock_only_me(only_me);
+    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
@@ skipping 23 matching lines @@
           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);
+          AutoUnlockMutex auto_unlock_only_me(only_me.Get());
 
-          DWORD result = ::WaitForSingleObject(metro_activation_event,
+          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_);
       }
@@ skipping 25 matching lines @@
             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);
+          ::SetEvent(metro_activation_event.Get());
       }
     }
   }
 
   return window_.hwnd() != NULL;
 }
 
 void ProcessSingleton::Cleanup() {
 }