Pass StatsTable shared memory via global descriptors on Posix rather than using named shared memory.

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                        |
@@ skipping 68 matching lines @@
   struct TableHeader {
     int version;
     int size;
     int max_counters;
     int max_threads;
   };
 
   // Construct a new Private based on expected size parameters, or
   // return NULL on failure.
   static Private* New(const std::string& name, int size,
                                 int max_threads, int max_counters);

[jar (doing other things), 2013/08/22 00:29:38]

nit: fix indentation.  Chromium standard for declarations and definitions that
have to wrap is to put one arg per line.

[rmcilroy, 2013/08/22 10:03:55]

Done.

 
-  SharedMemory* shared_memory() { return &shared_memory_; }
+  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; }
   int max_counters() const { return table_header_->max_counters; }
   int max_threads() const { return table_header_->max_threads; }
 
   // Accessors for our tables
   char* thread_name(int slot_id) const {
     return &thread_names_table_[
       (slot_id-1) * (StatsTable::kMaxThreadNameLength)];
   }
   PlatformThreadId* thread_tid(int slot_id) const {
     return &(thread_tid_table_[slot_id-1]);
   }
   int* thread_pid(int slot_id) const {
     return &(thread_pid_table_[slot_id-1]);
   }
   char* counter_name(int counter_id) const {
     return &counter_names_table_[
       (counter_id-1) * (StatsTable::kMaxCounterNameLength)];
   }
   int* row(int counter_id) const {
     return &data_table_[(counter_id-1) * max_threads()];
   }
 
  private:
   // Constructor is private because you should use New() instead.
-  Private()
-      : table_header_(NULL),
+  explicit Private(SharedMemory* shared_memory)
+      : 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(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);
 
-  SharedMemory shared_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_;
 };

[jar (doing other things), 2013/08/22 00:29:38]

nit: Probably NO_DEFAULT_COPY_OR_ASSIGN(...)

[rmcilroy, 2013/08/22 10:03:55]

Done (DISALLOW_COPY_AND_ASSIGN)

 
 // static
 StatsTable::Private* StatsTable::Private::New(const std::string& name,
                                               int size,
                                               int max_threads,
                                               int max_counters) {
-  scoped_ptr<Private> priv(new Private());
-  if (!priv->shared_memory_.CreateNamed(name, true, size))
+  scoped_ptr<SharedMemory> shared_memory(CreateSharedMemory(size));
+  if (!shared_memory.get())
     return NULL;
-  if (!priv->shared_memory_.Map(size))
+  if (!shared_memory->Map(size))
     return NULL;
-  void* memory = priv->shared_memory_.memory();
+  void* memory = shared_memory->memory();
 
+  scoped_ptr<Private> priv(new Private(shared_memory.release()));

[jar (doing other things), 2013/08/22 00:29:38]

nit: Style: Don't abbreviate in names.  Sadly, the word "private" is a reserved
word... so perhaps you can choose a better name for the class, and then for the
instance.

Possible choices (you can think of others that are better):
Internal
Helper

[rmcilroy, 2013/08/22 10:03:55]

Done (went with Internal)

   TableHeader* header = static_cast<TableHeader*>(memory);
 
   // If the version does not match, then assume the table needs
   // to be initialized.
   if (header->version != kTableVersion)
     priv->InitializeTable(memory, size, max_counters, max_threads);
 
   // We have a valid table, so compute our pointers.
   priv->ComputeMappedPointers(memory);
 
   return priv.release();
 }
 
+// static
+SharedMemory* StatsTable::Private::CreateSharedMemory(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);
+  }
+  // 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.CreateNamed(name, true, size))
+    return NULL;
+  return shared_memory.release();
+#endif
+}
+
 void StatsTable::Private::InitializeTable(void* memory, int size,
                                           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;
@@ skipping 358 matching lines @@
   TLSData* data =
     static_cast<TLSData*>(tls_index_.Get());
   if (!data)
     return NULL;
 
   DCHECK(data->slot);
   DCHECK_EQ(data->table, this);
   return data;
 }
 
+#if defined(OS_POSIX)
+SharedMemoryHandle StatsTable::GetSharedMemoryHandle() const {
+  return impl_ ? impl_->shared_memory()->handle() : SharedMemory::NULLHandle();
+}
+#endif
+
 }  // namespace base