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"
@@ skipping 130 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

[cpu_(ooo_6.6-7.5), 2012/07/13 23:16:53]

why do it if the directory is not remote?

[pastarmovj, 2012/07/14 01:21:58]

To check if a path contains a reparse point hence it is potentially a network
share we have to create(or have) a non-empty file, memory map it and then ask
the OS to tell us if this memory mapped file has reparse points in its name. It
seemed to me cheaper to just try and create an empty file regardless whether we
are on a net share or not as this will actually be cheaper than to check first.
WDYT?
BTW the code below can be made to open or create as needed in a single call
instead of doing it twice in a row. I just did it this way to be able to
investigate and validate the expectations on the error codes set by both
operations separately. So the end code will be as simple as try to open  and let
it be.

+    // machine that uses the same profile.
+    FilePath lock_file_path = user_data_dir.AppendASCII("lockfile");
+    lock_file_ = CreateFile(lock_file_path.value().c_str(),
+                            GENERIC_WRITE,
+                            FILE_SHARE_READ,
+                            NULL,
+                            CREATE_NEW,
+                            FILE_ATTRIBUTE_NORMAL | FILE_FLAG_DELETE_ON_CLOSE,
+                            NULL);
+    DWORD error = GetLastError();
+    LOG(ERROR) << "@@@ First lock file attempt : " << lock_file_
+               << " code " << error;
+    if (lock_file_ == INVALID_HANDLE_VALUE && error == ERROR_FILE_EXISTS) {
+      // If we are inside here that means that some other machine has or had an
+      // active chrome process. This second try destinguishes between stale file
+      // and really actively opened file. We should directly do this check but
+      // for completeness we do both check sequentially.
+      lock_file_ = CreateFile(lock_file_path.value().c_str(),
+                              GENERIC_WRITE,
+                              FILE_SHARE_READ,
+                              NULL,
+                              OPEN_EXISTING,
+                              FILE_ATTRIBUTE_NORMAL | FILE_FLAG_DELETE_ON_CLOSE,
+                              NULL);
+      error = GetLastError();
+      LOG(ERROR) << "@@@ Second lock file attempt : " << lock_file_
+                 << " code " << error;
+    }
+    if (lock_file_ == INVALID_HANDLE_VALUE) {
+      // If both attempts failed we are left with no other option but to admit
+      // defeat and make harakiri to ourselves.
+      LOG(ERROR) << "@@@ There is another chrome process that is still active";
+    }
+
+    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_);

[cpu_(ooo_6.6-7.5), 2012/07/13 23:16:53]

why close it here?

[pastarmovj, 2012/07/14 01:21:58]

Mmmm...clean up...I guess :-) . 
Well basically the file is marked wirh FILE_FLAG_DELETE_ON_CLOSE and the OS will
close the file when we die but why risk it when we can in a controlled way close
the file here?

 }
 
 ProcessSingleton::NotifyResult ProcessSingleton::NotifyOtherProcess() {
   if (is_virtualized_)
     return PROCESS_NOTIFIED;  // We already spawned the process in this case.
   else if (!remote_window_)
     return PROCESS_NONE;
 
   // Found another window, send our command line to it
   // format is "START\0<<<current directory>>>\0<<<commandline>>>".
@@ skipping 72 matching lines @@
     return result;
   return Create(notification_callback) ? PROCESS_NONE : PROFILE_IN_USE;
 }
 
 // On Windows, there is no need to call Create() since the message
 // window is created in the constructor but to avoid having more
 // platform specific code in browser_main.cc we tolerate calls to
 // Create().
 bool ProcessSingleton::Create(
     const NotificationCallback& notification_callback) {
+  if (lock_file_ == INVALID_HANDLE_VALUE)
+    return false;
+

[cpu_(ooo_6.6-7.5), 2012/07/13 23:16:53]

and not sure we need this here either..

[pastarmovj, 2012/07/14 01:21:58]

This actually will make the newly started process die if there is already
another chrome instance running somewhere else.
What really misses here is UI to to notify the user why we just exited silently.
But I think for this kind of notification we can't do much better but to show a
message box as we don't really want to power up any of the heavy duty browser
stuff. Even localization might be a tough issue provided that we can't check the
user's pref for locale but only rely on the system locale at best.

   DCHECK(!remote_window_);
   DCHECK(notification_callback_.is_null());
 
   if (window_ != NULL)
     notification_callback_ = notification_callback;
 
   return window_ != NULL;
 }
 
 void ProcessSingleton::Cleanup() {
@@ skipping 35 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);
 }