Use PlatformThreadId, not int when dealing with thread ids.

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/process_util.h"
 #include "base/shared_memory.h"
@@ skipping 108 matching lines @@
   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)];
   }
-  int* thread_tid(int slot_id) const {
+  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.
   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);
 
   base::SharedMemory shared_memory_;
   TableHeader* table_header_;
   char* thread_names_table_;
-  int* thread_tid_table_;
+  PlatformThreadId* thread_tid_table_;
   int* thread_pid_table_;
   char* counter_names_table_;
   int* data_table_;
 };
 
 // static
 StatsTablePrivate* StatsTablePrivate::New(const std::string& name,
                                           int size,
                                           int max_threads,
                                           int max_counters) {
@@ skipping 41 matching lines @@
   offset += AlignOffset(offset);
 
   // Verify we're looking at a valid StatsTable.
   DCHECK_EQ(table_header_->version, kTableVersion);
 
   thread_names_table_ = reinterpret_cast<char*>(data + offset);
   offset += sizeof(char) *
             max_threads() * StatsTable::kMaxThreadNameLength;
   offset += AlignOffset(offset);
 
-  thread_tid_table_ = reinterpret_cast<int*>(data + offset);
+  thread_tid_table_ = reinterpret_cast<PlatformThreadId*>(data + offset);
   offset += sizeof(int) * max_threads();
   offset += AlignOffset(offset);
 
   thread_pid_table_ = reinterpret_cast<int*>(data + offset);
   offset += sizeof(int) * max_threads();
   offset += AlignOffset(offset);
 
   counter_names_table_ = reinterpret_cast<char*>(data + offset);
   offset += sizeof(char) *
             max_counters() * StatsTable::kMaxCounterNameLength;
@@ skipping 318 matching lines @@
       return NULL;
 
   // Find the counter id for the counter.
   std::string str_name(name);
   int counter = table->FindCounter(str_name);
 
   // Now we can find the location in the table.
   return table->GetLocation(counter, slot);
 }