Get service processes working on Mac and Linux.

chrome/common/service_process_util.cc

 // Copyright (c) 2010 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 <algorithm>
 
 #include "base/file_util.h"
 #include "base/logging.h"
+#include "base/mac/scoped_nsautorelease_pool.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
+#include "base/sha1.h"
 #include "base/singleton.h"
 #include "base/string16.h"
+#include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/version.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/service_process_util.h"
 
 namespace {
 
 // This should be more than enough to hold a version string assuming each part
 // of the version string is an int64.
 const uint32 kMaxVersionStringLength = 256;
 
 // The structure that gets written to shared memory.
 struct ServiceProcessSharedData {
   char service_process_version[kMaxVersionStringLength];
   base::ProcessId service_process_pid;
 };
 
 // Gets the name of the shared memory used by the service process to write its
 // version. The name is not versioned.
 std::string GetServiceProcessSharedMemName() {
   return GetServiceProcessScopedName("_service_shmem");
 }
 
-// Reads the named shared memory to get the shared data. Returns false if no
-// matching shared memory was found.
-bool GetServiceProcessSharedData(std::string* version, base::ProcessId* pid) {
-  scoped_ptr<base::SharedMemory> shared_mem_service_data;
-  shared_mem_service_data.reset(new base::SharedMemory());
-  ServiceProcessSharedData* service_data = NULL;
-  if (shared_mem_service_data.get() &&
-      shared_mem_service_data->Open(GetServiceProcessSharedMemName(), true) &&
-      shared_mem_service_data->Map(sizeof(ServiceProcessSharedData))) {
-    service_data = reinterpret_cast<ServiceProcessSharedData*>(
-        shared_mem_service_data->memory());
-    // Make sure the version in shared memory is null-terminated. If it is not,
-    // treat it as invalid.
-    if (version && memchr(service_data->service_process_version, '\0',
-                          sizeof(service_data->service_process_version)))
-      *version = service_data->service_process_version;
-    if (pid)
-      *pid = service_data->service_process_pid;
-    return true;
-  }
-  return false;
-}
-
 enum ServiceProcessRunningState {
   SERVICE_NOT_RUNNING,
   SERVICE_OLDER_VERSION_RUNNING,
   SERVICE_SAME_VERSION_RUNNING,
   SERVICE_NEWER_VERSION_RUNNING,
 };
 
 ServiceProcessRunningState GetServiceProcessRunningState(
-    std::string* service_version_out) {
+    std::string* service_version_out, base::ProcessId* pid_out) {
   std::string version;
-  GetServiceProcessSharedData(&version, NULL);
+  GetServiceProcessSharedData(&version, pid_out);
   if (version.empty())
     return SERVICE_NOT_RUNNING;
 
   // At this time we have a version string. Set the out param if it exists.
   if (service_version_out)
     *service_version_out = version;
 
   scoped_ptr<Version> service_version(Version::GetVersionFromString(version));
   // If the version string is invalid, treat it like an older version.
   if (!service_version.get())
@@ skipping 21 matching lines @@
   } else if (service_version->CompareTo(*running_version) > 0) {
     return SERVICE_NEWER_VERSION_RUNNING;
   }
   return SERVICE_SAME_VERSION_RUNNING;
 }
 
 
 }  // namespace
 
 // Return a name that is scoped to this instance of the service process. We
-// use the user-data-dir as a scoping prefix.
+// use the hash of the user-data-dir as a scoping prefix. We can't use
+// the user-data-dir itself as we have limits on the size of the lock names.
 std::string GetServiceProcessScopedName(const std::string& append_str) {
   FilePath user_data_dir;
   PathService::Get(chrome::DIR_USER_DATA, &user_data_dir);
 #if defined(OS_WIN)
-  std::string scoped_name = WideToUTF8(user_data_dir.value());
+  std::string user_data_dir_path = WideToUTF8(user_data_dir.value());
 #elif defined(OS_POSIX)
-  std::string scoped_name = user_data_dir.value();
+  std::string user_data_dir_path = user_data_dir.value();
 #endif  // defined(OS_WIN)
-  std::replace(scoped_name.begin(), scoped_name.end(), '\\', '!');
-  std::replace(scoped_name.begin(), scoped_name.end(), '/', '!');
-  scoped_name.append(append_str);
-  return scoped_name;
+  std::string hash = base::SHA1HashString(user_data_dir_path);
+  std::string hex_hash = base::HexEncode(hash.c_str(), hash.length());
+  return hex_hash + "." + append_str;
 }
 
 // Return a name that is scoped to this instance of the service process. We
 // use the user-data-dir and the version as a scoping prefix.
 std::string GetServiceProcessScopedVersionedName(
     const std::string& append_str) {
   std::string versioned_str;
   chrome::VersionInfo version_info;
   DCHECK(version_info.is_valid());
   versioned_str.append(version_info.Version());
   versioned_str.append(append_str);
   return GetServiceProcessScopedName(versioned_str);
 }
 
 // Gets the name of the service process IPC channel.
 std::string GetServiceProcessChannelName() {
   return GetServiceProcessScopedVersionedName("_service_ipc");
 }
 
-base::ProcessId GetServiceProcessPid() {
-  base::ProcessId pid = 0;
-  GetServiceProcessSharedData(NULL, &pid);
-  return pid;
+// Reads the named shared memory to get the shared data. Returns false if no
+// matching shared memory was found.
+bool GetServiceProcessSharedData(std::string* version, base::ProcessId* pid) {
+  scoped_ptr<base::SharedMemory> shared_mem_service_data;

[Scott Byer, 2011/02/02 00:12:38]

Did this function need to get moved? It's not like the functions are in header
declaration order before or after the move, and it would help minimize
differences back in the old location.

[dmac, 2011/02/02 00:56:25]

Yes, I needed to take it out of the anonymous namespace that it was in.

+  shared_mem_service_data.reset(new base::SharedMemory());
+  ServiceProcessSharedData* service_data = NULL;
+  if (shared_mem_service_data.get() &&
+      shared_mem_service_data->Open(GetServiceProcessSharedMemName(), true) &&
+      shared_mem_service_data->Map(sizeof(ServiceProcessSharedData))) {
+    service_data = reinterpret_cast<ServiceProcessSharedData*>(
+        shared_mem_service_data->memory());
+    // Make sure the version in shared memory is null-terminated. If it is not,
+    // treat it as invalid.
+    if (version && memchr(service_data->service_process_version, '\0',
+                          sizeof(service_data->service_process_version)))
+      *version = service_data->service_process_version;
+    if (pid)
+      *pid = service_data->service_process_pid;
+    return true;
+  }
+  return false;
 }
 
 ServiceProcessState::ServiceProcessState() : state_(NULL) {
 }
 
 ServiceProcessState::~ServiceProcessState() {
+  if (shared_mem_service_data_.get()) {
+    // Delete needs a pool wrapped around it because it call some obj-c on Mac.
+    base::mac::ScopedNSAutoreleasePool pool;
+    shared_mem_service_data_->Delete(GetServiceProcessSharedMemName());
+  }
   TearDownState();
 }
 
 // static
 ServiceProcessState* ServiceProcessState::GetInstance() {
   return Singleton<ServiceProcessState>::get();
 }
 
 bool ServiceProcessState::Initialize() {
   if (!TakeSingletonLock()) {
     return false;
   }
   // Now that we have the singleton, take care of killing an older version, if
   // it exists.
   if (ShouldHandleOtherVersion() && !HandleOtherVersion())
     return false;
 
   // TODO(sanjeevr): We can probably use the shared mem as the sole singleton
   // mechanism. For that the shared mem class needs to return whether it created
   // new instance or opened an existing one. Also shared memory on Linux uses
   // a file on disk which is not deleted when the process exits.
 
   // Now that we have the singleton, let is also write the version we are using
   // to shared memory. This can be used by a newer service to signal us to exit.
   return CreateSharedData();
 }
 
 bool ServiceProcessState::HandleOtherVersion() {
   std::string running_version;
+  base::ProcessId process_id;
   ServiceProcessRunningState state =
-      GetServiceProcessRunningState(&running_version);
+      GetServiceProcessRunningState(&running_version, &process_id);
   switch (state) {
     case SERVICE_SAME_VERSION_RUNNING:
     case SERVICE_NEWER_VERSION_RUNNING:
       return false;
     case SERVICE_OLDER_VERSION_RUNNING:
       // If an older version is running, kill it.
-      ForceServiceProcessShutdown(running_version);
+      ForceServiceProcessShutdown(running_version, process_id);
       break;
     case SERVICE_NOT_RUNNING:
       break;
   }
   return true;
 }
 
 bool ServiceProcessState::CreateSharedData() {
   chrome::VersionInfo version_info;
   if (!version_info.is_valid()) {
     NOTREACHED() << "Failed to get current file version";
     return false;
   }
   if (version_info.Version().length() >= kMaxVersionStringLength) {
     NOTREACHED() << "Version string length is << " <<
         version_info.Version().length() << "which is longer than" <<
         kMaxVersionStringLength;
     return false;
   }
 
-  scoped_ptr<base::SharedMemory> shared_mem_service_data;
-  shared_mem_service_data.reset(new base::SharedMemory());
+  scoped_ptr<base::SharedMemory> shared_mem_service_data(
+      new base::SharedMemory());
   if (!shared_mem_service_data.get())
     return false;
 
   uint32 alloc_size = sizeof(ServiceProcessSharedData);
   if (!shared_mem_service_data->CreateNamed(GetServiceProcessSharedMemName(),
                                             true, alloc_size))
     return false;
 
   if (!shared_mem_service_data->Map(alloc_size))
     return false;
 
   memset(shared_mem_service_data->memory(), 0, alloc_size);
   ServiceProcessSharedData* shared_data =
       reinterpret_cast<ServiceProcessSharedData*>(
           shared_mem_service_data->memory());
   memcpy(shared_data->service_process_version, version_info.Version().c_str(),
          version_info.Version().length());
   shared_data->service_process_pid = base::GetCurrentProcId();
   shared_mem_service_data_.reset(shared_mem_service_data.release());
   return true;
 }
 
-
 std::string ServiceProcessState::GetAutoRunKey() {
   return GetServiceProcessScopedName("_service_run");
 }
+
+void ServiceProcessState::SignalStopped() {
+  TearDownState();
+  shared_mem_service_data_.reset();
+}