Implement lock file for windows profiles.

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 "base/base_paths.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/wrapped_window_proc.h"
 #include "chrome/browser/ui/simple_message_box.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/installer/util/wmi.h"
 #include "content/public/common/result_codes.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/win/hwnd_util.h"
 
 namespace {
 
+const char kLockfile[] = "lockfile";
+
 // Checks the visibility of the enumerated window and signals once a visible
 // window has been found.
 BOOL CALLBACK BrowserWindowEnumeration(HWND window, LPARAM param) {
   bool* result = reinterpret_cast<bool*>(param);
   *result = IsWindowVisible(window) != 0;
   // Stops enumeration if a visible window has been found.
   return !*result;
 }
 
 // This function thunks to the object's version of the windowproc, taking in
@@ skipping 105 matching lines @@
     return true;
   }
   return false;
 }
 
 // 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.
 ProcessSingleton::ProcessSingleton(const FilePath& user_data_dir)
     : window_(NULL), locked_(false), foreground_window_(NULL),
-    is_virtualized_(false) {
+    is_virtualized_(false), lock_file_(INVALID_HANDLE_VALUE) {
   remote_window_ = FindWindowEx(HWND_MESSAGE, NULL,
                                 chrome::kMessageWindowClass,
                                 user_data_dir.value().c_str());
   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.
     std::wstring mutex_name(L"Local\\ChromeProcessSingletonStartup!");
     base::win::ScopedHandle only_me(
         CreateMutex(NULL, FALSE, mutex_name.c_str()));
     DCHECK(only_me.Get() != NULL) << "GetLastError = " << GetLastError();
 
     // This is how we acquire the mutex (as opposed to the initial ownership).
     DWORD result = WaitForSingleObject(only_me, INFINITE);
     DCHECK(result == WAIT_OBJECT_0) << "Result = " << result <<
         "GetLastError = " << GetLastError();
 
     // 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_ = FindWindowEx(HWND_MESSAGE, NULL,
                                   chrome::kMessageWindowClass,
                                   user_data_dir.value().c_str());
-    if (!remote_window_) {
+
+    // We have to make sure there is no Chrome instance running on another
+    // machine that uses the same profile.
+    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();

[cpu_(ooo_6.6-7.5), 2012/07/16 20:36:31]

this version I like better. Now for two local chrome instances how does this
work? it seems that now we have two mechanisms for process exclusion so I don't
think we need to do the file if the remote_window is there and secondly it feels
that if we can't open the file we should query it to see if it is remote.

[pastarmovj, 2012/07/16 21:17:53]

For two local instances the first one will acquire the lock file and create the
windows. Whereas the second will find the remote window and will fail to acquire
the lock file and will exit but will first send the appropriate command to the 
other process via the message channel.

I changed the logic as you suggested to only try to create the lock file if the
remote_window_ is null but I don't see why should we query the lock file if it
is remote or not? This information is implicitly avilable to us though the check
for the remote window - we have three cases:
1. No local chrome + no remote chrome: Neither remote window  present nor lock
file - we create both the window and the lock file.
2. Local chrome + no remote chrome: We have remote window and lock file. We
don't even try to create the lock file (as per the newly updated logic) and we
send a message to the other process through the window handle.
3. No local chrome + remote chrome: We have no remote window but we have a lock
file: We fail to recreate the lock file and exit the process writing a log entry
about the reason.

The chance of having both local and remote instance shouldn't happen as this is
exactly what we are guarding against.

+    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 (!remote_window_ && lock_file_ != INVALID_HANDLE_VALUE) {
       HINSTANCE hinst = base::GetModuleFromAddress(&ThunkWndProc);
 
       WNDCLASSEX wc = {0};
       wc.cbSize = sizeof(wc);
       wc.lpfnWndProc = base::win::WrappedWindowProc<ThunkWndProc>;
       wc.hInstance = hinst;
       wc.lpszClassName = chrome::kMessageWindowClass;
       ATOM clazz = ::RegisterClassEx(&wc);
       DCHECK(clazz);
 
@@ skipping 11 matching lines @@
 
 ProcessSingleton::~ProcessSingleton() {
   // We need to unregister the window as late as possible so that we can detect
   // another instance of chrome running. Otherwise we may end up writing out
   // data while a new chrome is starting up.
   if (window_) {
     ::DestroyWindow(window_);
     ::UnregisterClass(chrome::kMessageWindowClass,
                       base::GetModuleFromAddress(&ThunkWndProc));
   }
+  if (lock_file_ != INVALID_HANDLE_VALUE)
+    CloseHandle(lock_file_);
 }
 
 ProcessSingleton::NotifyResult ProcessSingleton::NotifyOtherProcess() {
   if (is_virtualized_)
     return PROCESS_NOTIFIED;  // We already spawned the process in this case.
+  if (lock_file_ == INVALID_HANDLE_VALUE && !remote_window_)
+    return LOCK_ERROR;
   else if (!remote_window_)
     return PROCESS_NONE;
 
   // Found another window, send our command line to it
   // format is "START\0<<<current directory>>>\0<<<commandline>>>".
   std::wstring to_send(L"START\0", 6);  // want the NULL in the string.
   FilePath cur_dir;
   if (!PathService::Get(base::DIR_CURRENT, &cur_dir))
     return PROCESS_NONE;
   to_send.append(cur_dir.value());
@@ skipping 122 matching lines @@
   switch (message) {
     case WM_COPYDATA:
       return OnCopyData(reinterpret_cast<HWND>(wparam),
                         reinterpret_cast<COPYDATASTRUCT*>(lparam));
     default:
       break;
   }
 
   return ::DefWindowProc(hwnd, message, wparam, lparam);
 }