Remove IPC dependency from base

base/metrics/stats_table.cc

 // Copyright (c) 2011 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 "base/metrics/stats_table.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/shared_memory.h"
 #include "base/process/process_handle.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread_local_storage.h"
 
-#if defined(OS_POSIX)
-#include "base/posix/global_descriptors.h"
-#include "errno.h"
-#include "ipc/ipc_descriptors.h"
-#endif
-
 namespace base {
 
 // The StatsTable uses a shared memory segment that is laid out as follows
 //
 // +-------------------------------------------+
 // | Version | Size | MaxCounters | MaxThreads |
 // +-------------------------------------------+
 // | Thread names table                        |
 // +-------------------------------------------+
 // | Thread TID table                          |
@@ skipping 65 matching lines @@
   // Various header information contained in the memory mapped segment.
   struct TableHeader {
     int version;
     int size;
     int max_counters;
     int max_threads;
   };
 
   // Construct a new Internal based on expected size parameters, or
   // return NULL on failure.
-  static Internal* New(const std::string& name,
+  static Internal* New(const StatsTable::TableIdentifier& table,
                        int size,
                        int max_threads,
                        int max_counters);
 
   SharedMemory* shared_memory() { return shared_memory_.get(); }
 
   // Accessors for our header pointers
   TableHeader* table_header() const { return table_header_; }
   int version() const { return table_header_->version; }
   int size() const { return table_header_->size; }
@@ skipping 25 matching lines @@
       : shared_memory_(shared_memory),
         table_header_(NULL),
         thread_names_table_(NULL),
         thread_tid_table_(NULL),
         thread_pid_table_(NULL),
         counter_names_table_(NULL),
         data_table_(NULL) {
   }
 
   // Create or open the SharedMemory used by the stats table.
-  static SharedMemory* CreateSharedMemory(const std::string& name,
-                                          int size);
+  static SharedMemory* CreateSharedMemory(
+      const StatsTable::TableIdentifier& table,
+      int size);
 
   // Initializes the table on first access.  Sets header values
   // appropriately and zeroes all counters.
   void InitializeTable(void* memory, int size, int max_counters,
                        int max_threads);
 
   // Initializes our in-memory pointers into a pre-created StatsTable.
   void ComputeMappedPointers(void* memory);
 
   scoped_ptr<SharedMemory> shared_memory_;
   TableHeader* table_header_;
   char* thread_names_table_;
   PlatformThreadId* thread_tid_table_;
   int* thread_pid_table_;
   char* counter_names_table_;
   int* data_table_;
 
   DISALLOW_COPY_AND_ASSIGN(Internal);
 };
 
 // static
-StatsTable::Internal* StatsTable::Internal::New(const std::string& name,
-                                                int size,
-                                                int max_threads,
-                                                int max_counters) {
-  scoped_ptr<SharedMemory> shared_memory(CreateSharedMemory(name, size));
+StatsTable::Internal* StatsTable::Internal::New(
+    const StatsTable::TableIdentifier& table,
+    int size,
+    int max_threads,
+    int max_counters) {
+  scoped_ptr<SharedMemory> shared_memory(CreateSharedMemory(table, size));
   if (!shared_memory.get())
     return NULL;
   if (!shared_memory->Map(size))
     return NULL;
   void* memory = shared_memory->memory();
 
   scoped_ptr<Internal> internal(new Internal(shared_memory.release()));
   TableHeader* header = static_cast<TableHeader*>(memory);
 
   // If the version does not match, then assume the table needs
   // to be initialized.
   if (header->version != kTableVersion)
     internal->InitializeTable(memory, size, max_counters, max_threads);
 
   // We have a valid table, so compute our pointers.
   internal->ComputeMappedPointers(memory);
 
   return internal.release();
 }
 
 // static
-SharedMemory* StatsTable::Internal::CreateSharedMemory(const std::string& name,
-                                                       int size) {
+SharedMemory* StatsTable::Internal::CreateSharedMemory(
+    const StatsTable::TableIdentifier& table,
+    int size) {
 #if defined(OS_POSIX)
-  GlobalDescriptors* global_descriptors = GlobalDescriptors::GetInstance();
-  if (global_descriptors->MaybeGet(kStatsTableSharedMemFd) != -1) {
-    // Open the shared memory file descriptor passed by the browser process.
-    FileDescriptor file_descriptor(
-        global_descriptors->Get(kStatsTableSharedMemFd), false);
-    return new SharedMemory(file_descriptor, false);
-  }
+  // Check for existing table.
+  if (table.fd != -1)
+    return new SharedMemory(table, false);
+
   // Otherwise we need to create it.
   scoped_ptr<SharedMemory> shared_memory(new SharedMemory());
   if (!shared_memory->CreateAnonymous(size))
     return NULL;
   return shared_memory.release();
 #elif defined(OS_WIN)
   scoped_ptr<SharedMemory> shared_memory(new SharedMemory());
-  if (!shared_memory->CreateNamedDeprecated(name, true, size))
-    return NULL;
+  if (table.empty()) {
+    // Create an anonymous table.
+    if (!shared_memory->CreateAnonymous(size))
+      return NULL;
+  } else {
+    // Create a named table for sharing between processes.
+    if (!shared_memory->CreateNamedDeprecated(table, true, size))
+      return NULL;
+  }
   return shared_memory.release();
 #endif
 }
 
 void StatsTable::Internal::InitializeTable(void* memory, int size,
-                                          int max_counters,
-                                          int max_threads) {
+                                           int max_counters,
+                                           int max_threads) {
   // Zero everything.
   memset(memory, 0, size);
 
   // Initialize the header.
   TableHeader* header = static_cast<TableHeader*>(memory);
   header->version = kTableVersion;
   header->size = size;
   header->max_counters = max_counters;
   header->max_threads = max_threads;
 }
@@ skipping 40 matching lines @@
 // Each thread that calls RegisterThread in the StatsTable will have
 // a TLSData stored in its TLS.
 struct StatsTable::TLSData {
   StatsTable* table;
   int slot;
 };
 
 // We keep a singleton table which can be easily accessed.
 StatsTable* global_table = NULL;
 
-StatsTable::StatsTable(const std::string& name, int max_threads,
+StatsTable::StatsTable(const TableIdentifier& table,
+                       int max_threads,
                        int max_counters)
     : internal_(NULL),
       tls_index_(SlotReturnFunction) {
   int table_size =
     AlignedSize(sizeof(Internal::TableHeader)) +
     AlignedSize((max_counters * sizeof(char) * kMaxCounterNameLength)) +
     AlignedSize((max_threads * sizeof(char) * kMaxThreadNameLength)) +
     AlignedSize(max_threads * sizeof(int)) +
     AlignedSize(max_threads * sizeof(int)) +
     AlignedSize((sizeof(int) * (max_counters * max_threads)));
 
-  internal_ = Internal::New(name, table_size, max_threads, max_counters);
+  internal_ = Internal::New(table, table_size, max_threads, max_counters);
 
   if (!internal_)
     DPLOG(ERROR) << "StatsTable did not initialize";
 }
 
 StatsTable::~StatsTable() {
   // Before we tear down our copy of the table, be sure to
   // unregister our thread.
   UnregisterThread();
 
@@ skipping 292 matching lines @@
 
 #if defined(OS_POSIX)
 SharedMemoryHandle StatsTable::GetSharedMemoryHandle() const {
   if (!internal_)
     return SharedMemory::NULLHandle();
   return internal_->shared_memory()->handle();
 }
 #endif
 
 }  // namespace base