Cleanup: Convert const char* kFoo to const char kFoo[].

base/memory/shared_memory_unittest.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 "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/shared_memory.h"
 #include "base/process/kill.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 47 matching lines @@
   void ThreadMain() override {
 #if defined(OS_MACOSX)
     mac::ScopedNSAutoreleasePool pool;
 #endif
     const uint32 kDataSize = 1024;
     SharedMemory memory;
     bool rv = memory.CreateNamedDeprecated(s_test_name_, true, kDataSize);
     EXPECT_TRUE(rv);
     rv = memory.Map(kDataSize);
     EXPECT_TRUE(rv);
-    int *ptr = static_cast<int*>(memory.memory()) + id_;
+    int* ptr = static_cast<int*>(memory.memory()) + id_;
     EXPECT_EQ(0, *ptr);
 
     for (int idx = 0; idx < 100; idx++) {
       *ptr = idx;
       PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(1));
       EXPECT_EQ(*ptr, idx);
     }
     // Reset back to 0 for the next test that uses the same name.
     *ptr = 0;
 
     memory.Close();
   }
 
  private:
   int16 id_;
 
-  static const char* const s_test_name_;
+  static const char s_test_name_[];
 
   DISALLOW_COPY_AND_ASSIGN(MultipleThreadMain);
 };
 
-const char* const MultipleThreadMain::s_test_name_ =
+const char MultipleThreadMain::s_test_name_[] =
     "SharedMemoryOpenThreadTest";
 
 // TODO(port):
 // This test requires the ability to pass file descriptors between processes.
 // We haven't done that yet in Chrome for POSIX.
 #if defined(OS_WIN)
 // Each thread will open the shared memory.  Each thread will take the memory,
 // and keep changing it while trying to lock it, with some small pauses in
 // between. Verify that each thread's value in the shared memory is always
 // correct.
 class MultipleLockThread : public PlatformThread::Delegate {
  public:
   explicit MultipleLockThread(int id) : id_(id) {}
   virtual ~MultipleLockThread() {}
 
   // PlatformThread::Delegate interface.
-  virtual void ThreadMain() override {
+  void ThreadMain() override {
     const uint32 kDataSize = sizeof(int);
     SharedMemoryHandle handle = NULL;
     {
       SharedMemory memory1;
       EXPECT_TRUE(memory1.CreateNamedDeprecated(
           "SharedMemoryMultipleLockThreadTest", true, kDataSize));
       EXPECT_TRUE(memory1.ShareToProcess(GetCurrentProcess(), &handle));
       // TODO(paulg): Implement this once we have a posix version of
       // SharedMemory::ShareToProcess.
       EXPECT_TRUE(true);
@@ skipping 54 matching lines @@
   // Make sure we don't segfault. (it actually happened!)
   ASSERT_NE(memory1.memory(), static_cast<void*>(NULL));
   ASSERT_NE(memory2.memory(), static_cast<void*>(NULL));
 
   // Write data to the first memory segment, verify contents of second.
   memset(memory1.memory(), '1', kDataSize);
   EXPECT_EQ(memcmp(memory1.memory(), memory2.memory(), kDataSize), 0);
 
   // Close the first memory segment, and verify the second has the right data.
   memory1.Close();
-  char *start_ptr = static_cast<char *>(memory2.memory());
-  char *end_ptr = start_ptr + kDataSize;
+  char* start_ptr = static_cast<char*>(memory2.memory());
+  char* end_ptr = start_ptr + kDataSize;
   for (char* ptr = start_ptr; ptr < end_ptr; ptr++)
     EXPECT_EQ(*ptr, '1');
 
   // Close the second memory segment.
   memory2.Close();
 
   rv = memory1.Delete(test_name);
   EXPECT_TRUE(rv);
   rv = memory2.Delete(test_name);
   EXPECT_TRUE(rv);
@@ skipping 45 matching lines @@
   EXPECT_TRUE(rv);
 
   // The mapped memory2 must be at least the size of the original.
   EXPECT_GE(memory2.mapped_size(), kDataSize);
 
   // The mapped memory2 shouldn't exceed rounding for allocation granularity.
   EXPECT_LT(memory2.mapped_size(),
             kDataSize2 + base::SysInfo::VMAllocationGranularity());
 
   // Verify that opening memory2 didn't truncate or delete memory 1.
-  char *start_ptr = static_cast<char *>(memory2.memory());
-  char *end_ptr = start_ptr + kDataSize;
+  char* start_ptr = static_cast<char*>(memory2.memory());
+  char* end_ptr = start_ptr + kDataSize;
   for (char* ptr = start_ptr; ptr < end_ptr; ptr++) {
     EXPECT_EQ(*ptr, 'G');
   }
 
   memory1.Close();
   memory2.Close();
 
   rv = memory1.Delete(test_name);
   EXPECT_TRUE(rv);
 }
@@ skipping 97 matching lines @@
   const uint32 kDataSize = 8192;
 
   scoped_ptr<SharedMemory[]> memories(new SharedMemory[count]);
   scoped_ptr<int*[]> pointers(new int*[count]);
   ASSERT_TRUE(memories.get());
   ASSERT_TRUE(pointers.get());
 
   for (i = 0; i < count; i++) {
     rv = memories[i].CreateAndMapAnonymous(kDataSize);
     EXPECT_TRUE(rv);
-    int *ptr = static_cast<int*>(memories[i].memory());
+    int* ptr = static_cast<int*>(memories[i].memory());
     EXPECT_TRUE(ptr);
     pointers[i] = ptr;
   }
 
   for (i = 0; i < count; i++) {
     // zero out the first int in each except for i; for that one, make it 100.
     for (j = 0; j < count; j++) {
       if (i == j)
         pointers[j][0] = 100;
       else
@@ skipping 267 matching lines @@
       shared_memory.memory()) & (SharedMemory::MAP_MINIMUM_ALIGNMENT - 1));
   shared_memory.Close();
 }
 
 #if !defined(OS_IOS)  // iOS does not allow multiple processes.
 
 // On POSIX it is especially important we test shmem across processes,
 // not just across threads.  But the test is enabled on all platforms.
 class SharedMemoryProcessTest : public MultiProcessTest {
  public:
-
   static void CleanUp() {
     SharedMemory memory;
     memory.Delete(s_test_name_);
   }
 
   static int TaskTestMain() {
     int errors = 0;
 #if defined(OS_MACOSX)
     mac::ScopedNSAutoreleasePool pool;
 #endif
     const uint32 kDataSize = 1024;
     SharedMemory memory;
     bool rv = memory.CreateNamedDeprecated(s_test_name_, true, kDataSize);
     EXPECT_TRUE(rv);
     if (rv != true)
       errors++;
     rv = memory.Map(kDataSize);
     EXPECT_TRUE(rv);
     if (rv != true)
       errors++;
-    int *ptr = static_cast<int*>(memory.memory());
+    int* ptr = static_cast<int*>(memory.memory());
 
     for (int idx = 0; idx < 20; idx++) {
       memory.LockDeprecated();
       int i = (1 << 16) + idx;
       *ptr = i;
       PlatformThread::Sleep(TimeDelta::FromMilliseconds(10));
       if (*ptr != i)
         errors++;
       memory.UnlockDeprecated();
     }
 
     memory.Close();
     return errors;
   }
 
  private:
-  static const char* const s_test_name_;
+  static const char s_test_name_[];
 };
 
-const char* const SharedMemoryProcessTest::s_test_name_ = "MPMem";
+const char SharedMemoryProcessTest::s_test_name_[] = "MPMem";
 
 TEST_F(SharedMemoryProcessTest, Tasks) {
   SharedMemoryProcessTest::CleanUp();
 
   Process processes[kNumTasks];
   for (int index = 0; index < kNumTasks; ++index) {
     processes[index] = SpawnChild("SharedMemoryTestMain");
     ASSERT_TRUE(processes[index].IsValid());
   }
 
   int exit_code = 0;
   for (int index = 0; index < kNumTasks; ++index) {
     EXPECT_TRUE(processes[index].WaitForExit(&exit_code));
     EXPECT_EQ(0, exit_code);
   }
 
   SharedMemoryProcessTest::CleanUp();
 }
 
 MULTIPROCESS_TEST_MAIN(SharedMemoryTestMain) {
   return SharedMemoryProcessTest::TaskTestMain();
 }
 
 #endif  // !OS_IOS
 
 }  // namespace base