Clean up ChildProcessHost unique id generation.

content/common/child_process_host_impl.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 "content/common/child_process_host_impl.h"
 
 #include <limits>
 
-#include "base/atomicops.h"
+#include "base/atomic_sequence_num.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "base/process/process_metrics.h"
 #include "base/rand_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
 #include "content/common/child_process_messages.h"
 #include "content/common/gpu/client/gpu_memory_buffer_impl.h"
 #include "content/public/common/child_process_host_delegate.h"
 #include "content/public/common/content_paths.h"
 #include "content/public/common/content_switches.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/ipc_logging.h"
 
 #if defined(OS_LINUX)
 #include "base/linux_util.h"
 #elif defined(OS_WIN)
 #include "content/common/font_cache_dispatcher_win.h"
 #endif  // OS_LINUX
 
-#if defined(OS_MACOSX)
 namespace {
 
+#if defined(OS_MACOSX)
 // Given |path| identifying a Mac-style child process executable path, adjusts
 // it to correspond to |feature|. For a child process path such as
 // ".../Chromium Helper.app/Contents/MacOS/Chromium Helper", the transformed
 // path for feature "NP" would be
 // ".../Chromium Helper NP.app/Contents/MacOS/Chromium Helper NP". The new
 // path is returned.
 base::FilePath TransformPathForFeature(const base::FilePath& path,
                                  const std::string& feature) {
   std::string basename = path.BaseName().value();
 
@@ skipping 13 matching lines @@
 
   base::FilePath root_path = helper_app_path.DirName();
 
   std::string new_basename = basename;
   new_basename.append(1, ' ');
   new_basename.append(feature);
   std::string new_basename_app = new_basename;
   new_basename_app.append(kAppExtension);
 
   base::FilePath new_path = root_path.Append(new_basename_app)
-                               .Append(kContentsName)
-                               .Append(kMacOSName)
-                               .Append(new_basename);
+                                     .Append(kContentsName)
+                                     .Append(kMacOSName)
+                                     .Append(new_basename);
 
   return new_path;
 }
+#endif  // OS_MACOSX
+
+// Global atomic to generate child process unique IDs.
+base::StaticAtomicSequenceNumber g_unique_id;
 
 }  // namespace
-#endif  // OS_MACOSX
 
 namespace content {
 
-int ChildProcessHostImpl::kInvalidChildProcessId = -1;
+int ChildProcessHost::kInvalidUniqueID = -1;
 
 // static
 ChildProcessHost* ChildProcessHost::Create(ChildProcessHostDelegate* delegate) {
   return new ChildProcessHostImpl(delegate);
 }
 
 // static
 base::FilePath ChildProcessHost::GetChildPath(int flags) {
   base::FilePath child_path;
 
@@ skipping 113 matching lines @@
     *shared_memory_handle = base::SharedMemory::NULLHandle();
     NOTREACHED() << "Cannot create shared memory buffer";
     return;
   }
   shared_buf.GiveToProcess(child_process_handle, shared_memory_handle);
 }
 
 int ChildProcessHostImpl::GenerateChildProcessUniqueId() {
   // This function must be threadsafe.
   //
-  // TODO(ajwong): Why not StaticAtomicSequenceNumber?
-  static base::subtle::Atomic32 last_unique_child_id = 0;
-  int id = base::subtle::NoBarrier_AtomicIncrement(&last_unique_child_id, 1);
+  // Historically, this function returned ids started with 1, so in several
+  // places in the code a value of 0 (rather than kInvalidUniqueID) was used as
+  // an invalid value. So we retain those semantics.
+  int id = g_unique_id.GetNext() + 1;
 
-  CHECK_NE(kInvalidChildProcessId, id);
+  CHECK_NE(0, id);
+  CHECK_NE(kInvalidUniqueID, id);
 
   return id;
 }
 
 bool ChildProcessHostImpl::OnMessageReceived(const IPC::Message& msg) {
 #ifdef IPC_MESSAGE_LOG_ENABLED
   IPC::Logging* logger = IPC::Logging::GetInstance();
   if (msg.type() == IPC_LOGGING_ID) {
     logger->OnReceivedLoggingMessage(msg);
     return true;
@@ skipping 72 matching lines @@
     uint32 internalformat,
     gfx::GpuMemoryBufferHandle* handle) {
   handle->type = gfx::SHARED_MEMORY_BUFFER;
   AllocateSharedMemory(
       width * height * GpuMemoryBufferImpl::BytesPerPixel(internalformat),
       peer_handle_,
       &handle->handle);
 }
 
 }  // namespace content