Reduce header dependencies.

base/stats_table.cc

 // Copyright (c) 2006-2008 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/stats_table.h"
 
+#include "base/logging.h"
+#include "base/platform_thread.h"
+#include "base/shared_memory.h"
 #include "base/string_util.h"
-#include "base/logging.h"
 #include "base/thread_local_storage.h"
-#include "base/platform_thread.h"
 
 #if defined(OS_POSIX)
 #include "errno.h"
 #endif
 
 // The StatsTable uses a shared memory segment that is laid out as follows
 //
 // +-------------------------------------------+
 // | Version | Size | MaxCounters | MaxThreads |
 // +-------------------------------------------+
@@ skipping 87 matching lines @@
 class StatsTablePrivate {
  public:
   // Various header information contained in the memory mapped segment.
   struct TableHeader {
     int version;
     int size;
     int max_counters;
     int max_threads;
   };
 
-  // Create the StatsTablePrivate based on expected size parameters.
-  StatsTablePrivate(void* memory, int size, int max_threads, int max_counters);
+  // Construct a new StatsTablePrivate based on expected size parameters, or
+  // return NULL on failure.
+  static StatsTablePrivate* New(const std::wstring& name, int size,
+                                int max_threads, int max_counters);
+
+  SharedMemory* shared_memory() { return &shared_memory_; }
 
   // 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
   wchar_t* thread_name(int slot_id) const {
     return &thread_names_table_[
       (slot_id-1) * (StatsTable::kMaxThreadNameLength)];
   }
   int* 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]);
   }
   wchar_t* 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.
+  StatsTablePrivate() {}
+
   // 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_;
   TableHeader* table_header_;
   wchar_t* thread_names_table_;
   int* thread_tid_table_;
   int* thread_pid_table_;
   wchar_t* counter_names_table_;
   int* data_table_;
 };
 
-StatsTablePrivate::StatsTablePrivate(void* memory, int size, int max_threads,
-                                     int max_counters) {
+// static
+StatsTablePrivate* StatsTablePrivate::New(const std::wstring& name,
+                                          int size,
+                                          int max_threads,
+                                          int max_counters) {
+  scoped_ptr<StatsTablePrivate> priv(new StatsTablePrivate());
+
+  if (!priv->shared_memory_.Create(name, false, true, size))
+    return NULL;
+  if (!priv->shared_memory_.Map(size))
+    return NULL;
+  void* memory = priv->shared_memory_.memory();
+
   TableHeader* header = static_cast<TableHeader*>(memory);
+
   // If the version does not match, then assume the table needs
   // to be initialized.
   if (header->version != kTableVersion)
-    InitializeTable(memory, size, max_counters, max_threads);
+    priv->InitializeTable(memory, size, max_counters, max_threads);
 
   // We have a valid table, so compute our pointers.
-  ComputeMappedPointers(memory);
+  priv->ComputeMappedPointers(memory);
+
+  return priv.release();
 }
 
 void StatsTablePrivate::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);
@@ skipping 38 matching lines @@
   DCHECK_EQ(offset, size());
 }
 
 
 
 // We keep a singleton table which can be easily accessed.
 StatsTable* StatsTable::global_table_ = NULL;
 
 StatsTable::StatsTable(const std::wstring& name, int max_threads,
                        int max_counters)
-    : tls_index_(SlotReturnFunction) {
+    : impl_(NULL),
+      tls_index_(SlotReturnFunction) {
   int table_size =
     AlignedSize(sizeof(StatsTablePrivate::TableHeader)) +
     AlignedSize((max_counters * sizeof(wchar_t) * kMaxCounterNameLength)) +
     AlignedSize((max_threads * sizeof(wchar_t) * kMaxThreadNameLength)) +
     AlignedSize(max_threads * sizeof(int)) +
     AlignedSize(max_threads * sizeof(int)) +
     AlignedSize((sizeof(int) * (max_counters * max_threads)));
 
-  impl_ = NULL;
-  // TODO(mbelshe): Move this out of the constructor
-  if (shared_memory_.Create(name, false, true, table_size))
-    if (shared_memory_.Map(table_size))
-      impl_ = new StatsTablePrivate(shared_memory_.memory(), table_size,
-                                    max_threads, max_counters);
+  impl_ = StatsTablePrivate::New(name, table_size, max_threads, max_counters);
+
+  // TODO(port): clean up this error reporting.
 #if defined(OS_WIN)
   if (!impl_)
     LOG(ERROR) << "StatsTable did not initialize:" << GetLastError();
 #elif defined(OS_POSIX)
   if (!impl_)
     LOG(ERROR) << "StatsTable did not initialize:" << strerror(errno);
 #endif
 }
 
 StatsTable::~StatsTable() {
@@ skipping 13 matching lines @@
     global_table_ = NULL;
 }
 
 int StatsTable::RegisterThread(const std::wstring& name) {
   int slot = 0;
 
   // Registering a thread requires that we lock the shared memory
   // so that two threads don't grab the same slot.  Fortunately,
   // thread creation shouldn't happen in inner loops.
   {
-    SharedMemoryAutoLock lock(&shared_memory_);
+    SharedMemoryAutoLock lock(impl_->shared_memory());
     slot = FindEmptyThread();
     if (!slot) {
       return 0;
     }
 
     DCHECK(impl_);
 
     // We have space, so consume a column in the table.
     std::wstring thread_name = name;
     if (name.empty())
@@ skipping 135 matching lines @@
 int StatsTable::AddCounter(const std::wstring& name) {
   DCHECK(impl_);
 
   if (!impl_)
     return 0;
 
   int counter_id = 0;
   {
     // To add a counter to the shared memory, we need the
     // shared memory lock.
-    SharedMemoryAutoLock lock(&shared_memory_);
+    SharedMemoryAutoLock lock(impl_->shared_memory());
 
     // We have space, so create a new counter.
     counter_id = FindCounterOrEmptyRow(name);
     if (!counter_id)
       return 0;
 
     std::wstring counter_name = name;
     if (name.empty())
       counter_name = kUnknownName;
     base::wcslcpy(impl_->counter_name(counter_id), counter_name.c_str(),
@@ skipping 81 matching lines @@
       return NULL;
 
   // Find the counter id for the counter.
   std::wstring str_name(name);
   int counter = table->FindCounter(str_name);
 
   // Now we can find the location in the table.
   return table->GetLocation(counter, slot);
 }