base: Stop passing by non-const references in some more places.

These are mostly unit test changes. There are a fair number of
occurances still, but they are not easy (or possible) to change due
to STL, third_party, or template requirements.

R=Nico
BUG=464816

Review URL: https://codereview.chromium.org/992083002

Cr-Commit-Position: refs/heads/master@{#319812}

6 files changed, 62 insertions, 68 deletions

diff --git a/base/files/file_util_unittest.cc b/base/files/file_util_unittest.cc
index af932ce..b107b0f 100644
--- a/base/files/file_util_unittest.cc
+++ b/base/files/file_util_unittest.cc
@@ -197,9 +197,9 @@ class FileUtilTest : public PlatformTest {
 // interface to query whether a given file is present.
 class FindResultCollector {
  public:
-  explicit FindResultCollector(FileEnumerator& enumerator) {
+  explicit FindResultCollector(FileEnumerator* enumerator) {
     FilePath cur_file;
-    while (!(cur_file = enumerator.Next()).value().empty()) {
+    while (!(cur_file = enumerator->Next()).value().empty()) {
       FilePath::StringType path = cur_file.value();
       // The file should not be returned twice.
       EXPECT_TRUE(files_.end() == files_.find(path))
@@ -824,7 +824,7 @@ TEST_F(FileUtilTest, ChangeDirectoryPermissionsAndEnumerate) {
   // Make sure the file in the directory can't be enumerated.
   FileEnumerator f1(subdir_path, true, FileEnumerator::FILES);
   EXPECT_TRUE(PathExists(subdir_path));
-  FindResultCollector c1(f1);
+  FindResultCollector c1(&f1);
   EXPECT_EQ(0, c1.size());
   EXPECT_FALSE(GetPosixFilePermissions(file_name, &mode));
 
@@ -835,7 +835,7 @@ TEST_F(FileUtilTest, ChangeDirectoryPermissionsAndEnumerate) {
 
   // Make sure the file in the directory can be enumerated.
   FileEnumerator f2(subdir_path, true, FileEnumerator::FILES);
-  FindResultCollector c2(f2);
+  FindResultCollector c2(&f2);
   EXPECT_TRUE(c2.HasFile(file_name));
   EXPECT_EQ(1, c2.size());
 
@@ -1871,7 +1871,7 @@ TEST_F(FileUtilTest, FileEnumeratorTest) {
 
   // Only enumerate files.
   FileEnumerator f1(temp_dir_.path(), true, FileEnumerator::FILES);
-  FindResultCollector c1(f1);
+  FindResultCollector c1(&f1);
   EXPECT_TRUE(c1.HasFile(file1));
   EXPECT_TRUE(c1.HasFile(file2_abs));
   EXPECT_TRUE(c1.HasFile(dir2file));
@@ -1880,7 +1880,7 @@ TEST_F(FileUtilTest, FileEnumeratorTest) {
 
   // Only enumerate directories.
   FileEnumerator f2(temp_dir_.path(), true, FileEnumerator::DIRECTORIES);
-  FindResultCollector c2(f2);
+  FindResultCollector c2(&f2);
   EXPECT_TRUE(c2.HasFile(dir1));
   EXPECT_TRUE(c2.HasFile(dir2));
   EXPECT_TRUE(c2.HasFile(dir2inner));
@@ -1889,7 +1889,7 @@ TEST_F(FileUtilTest, FileEnumeratorTest) {
   // Only enumerate directories non-recursively.
   FileEnumerator f2_non_recursive(
       temp_dir_.path(), false, FileEnumerator::DIRECTORIES);
-  FindResultCollector c2_non_recursive(f2_non_recursive);
+  FindResultCollector c2_non_recursive(&f2_non_recursive);
   EXPECT_TRUE(c2_non_recursive.HasFile(dir1));
   EXPECT_TRUE(c2_non_recursive.HasFile(dir2));
   EXPECT_EQ(2, c2_non_recursive.size());
@@ -1898,7 +1898,7 @@ TEST_F(FileUtilTest, FileEnumeratorTest) {
   FileEnumerator f2_dotdot(temp_dir_.path(), false,
                            FileEnumerator::DIRECTORIES |
                            FileEnumerator::INCLUDE_DOT_DOT);
-  FindResultCollector c2_dotdot(f2_dotdot);
+  FindResultCollector c2_dotdot(&f2_dotdot);
   EXPECT_TRUE(c2_dotdot.HasFile(dir1));
   EXPECT_TRUE(c2_dotdot.HasFile(dir2));
   EXPECT_TRUE(c2_dotdot.HasFile(temp_dir_.path().Append(FPL(".."))));
@@ -1906,7 +1906,7 @@ TEST_F(FileUtilTest, FileEnumeratorTest) {
 
   // Enumerate files and directories.
   FileEnumerator f3(temp_dir_.path(), true, FILES_AND_DIRECTORIES);
-  FindResultCollector c3(f3);
+  FindResultCollector c3(&f3);
   EXPECT_TRUE(c3.HasFile(dir1));
   EXPECT_TRUE(c3.HasFile(dir2));
   EXPECT_TRUE(c3.HasFile(file1));
@@ -1918,7 +1918,7 @@ TEST_F(FileUtilTest, FileEnumeratorTest) {
 
   // Non-recursive operation.
   FileEnumerator f4(temp_dir_.path(), false, FILES_AND_DIRECTORIES);
-  FindResultCollector c4(f4);
+  FindResultCollector c4(&f4);
   EXPECT_TRUE(c4.HasFile(dir2));
   EXPECT_TRUE(c4.HasFile(dir2));
   EXPECT_TRUE(c4.HasFile(file1));
@@ -1927,7 +1927,7 @@ TEST_F(FileUtilTest, FileEnumeratorTest) {
 
   // Enumerate with a pattern.
   FileEnumerator f5(temp_dir_.path(), true, FILES_AND_DIRECTORIES, FPL("dir*"));
-  FindResultCollector c5(f5);
+  FindResultCollector c5(&f5);
   EXPECT_TRUE(c5.HasFile(dir1));
   EXPECT_TRUE(c5.HasFile(dir2));
   EXPECT_TRUE(c5.HasFile(dir2file));
@@ -1946,7 +1946,7 @@ TEST_F(FileUtilTest, FileEnumeratorTest) {
       // the file system so skip this test for XP.
       // Enumerate the reparse point.
       FileEnumerator f6(dir1, true, FILES_AND_DIRECTORIES);
-      FindResultCollector c6(f6);
+      FindResultCollector c6(&f6);
       FilePath inner2 = dir1.Append(FPL("inner"));
       EXPECT_TRUE(c6.HasFile(inner2));
       EXPECT_TRUE(c6.HasFile(inner2.Append(FPL("innerfile.txt"))));
@@ -1956,7 +1956,7 @@ TEST_F(FileUtilTest, FileEnumeratorTest) {
 
     // No changes for non recursive operation.
     FileEnumerator f7(temp_dir_.path(), false, FILES_AND_DIRECTORIES);
-    FindResultCollector c7(f7);
+    FindResultCollector c7(&f7);
     EXPECT_TRUE(c7.HasFile(dir2));
     EXPECT_TRUE(c7.HasFile(dir2));
     EXPECT_TRUE(c7.HasFile(file1));
@@ -1965,7 +1965,7 @@ TEST_F(FileUtilTest, FileEnumeratorTest) {
 
     // Should not enumerate inside dir1 when using recursion.
     FileEnumerator f8(temp_dir_.path(), true, FILES_AND_DIRECTORIES);
-    FindResultCollector c8(f8);
+    FindResultCollector c8(&f8);
     EXPECT_TRUE(c8.HasFile(dir1));
     EXPECT_TRUE(c8.HasFile(dir2));
     EXPECT_TRUE(c8.HasFile(file1));
diff --git a/base/json/json_value_serializer_unittest.cc b/base/json/json_value_serializer_unittest.cc
index 225ee67..b8aebe0 100644
--- a/base/json/json_value_serializer_unittest.cc
+++ b/base/json/json_value_serializer_unittest.cc
@@ -61,7 +61,7 @@ const char kWinLineEnds[] = "\r\n";
 const char kLinuxLineEnds[] = "\n";
 
 // Verifies the generated JSON against the expected output.
-void CheckJSONIsStillTheSame(Value& value) {
+void CheckJSONIsStillTheSame(const Value& value) {
   // Serialize back the output.
   std::string serialized_json;
   JSONStringValueSerializer str_serializer(&serialized_json);
diff --git a/base/test/histogram_tester.cc b/base/test/histogram_tester.cc
index 412059a..ea738b0 100644
--- a/base/test/histogram_tester.cc
+++ b/base/test/histogram_tester.cc
@@ -90,7 +90,7 @@ void HistogramTester::CheckBucketCount(
     const std::string& name,
     base::HistogramBase::Sample sample,
     base::HistogramBase::Count expected_count,
-    base::HistogramSamples& samples) const {
+    const base::HistogramSamples& samples) const {
   int actual_count = samples.GetCount(sample);
   std::map<std::string, HistogramSamples*>::const_iterator histogram_data;
   histogram_data = histograms_snapshot_.find(name);
@@ -104,9 +104,10 @@ void HistogramTester::CheckBucketCount(
       << ").";
 }
 
-void HistogramTester::CheckTotalCount(const std::string& name,
-                                      base::HistogramBase::Count expected_count,
-                                      base::HistogramSamples& samples) const {
+void HistogramTester::CheckTotalCount(
+    const std::string& name,
+    base::HistogramBase::Count expected_count,
+    const base::HistogramSamples& samples) const {
   int actual_count = samples.TotalCount();
   std::map<std::string, HistogramSamples*>::const_iterator histogram_data;
   histogram_data = histograms_snapshot_.find(name);
diff --git a/base/test/histogram_tester.h b/base/test/histogram_tester.h
index b672308..96317f9 100644
--- a/base/test/histogram_tester.h
+++ b/base/test/histogram_tester.h
@@ -59,14 +59,14 @@ class HistogramTester {
   void CheckBucketCount(const std::string& name,
                         base::HistogramBase::Sample sample,
                         base::Histogram::Count expected_count,
-                        base::HistogramSamples& samples) const;
+                        const base::HistogramSamples& samples) const;
 
   // Verifies that the total number of values recorded for the histogram |name|
   // is |expected_count|. This is checked against |samples| minus the snapshot
   // that was taken for |name|.
   void CheckTotalCount(const std::string& name,
                        base::Histogram::Count expected_count,
-                       base::HistogramSamples& samples) const;
+                       const base::HistogramSamples& samples) const;
 
   // Used to determine the histogram changes made during this instance's
   // lifecycle. This instance takes ownership of the samples, which are deleted
diff --git a/base/threading/thread_collision_warner_unittest.cc b/base/threading/thread_collision_warner_unittest.cc
index 26faff4..d7ce79e 100644
--- a/base/threading/thread_collision_warner_unittest.cc
+++ b/base/threading/thread_collision_warner_unittest.cc
@@ -146,24 +146,23 @@ TEST(ThreadCollisionTest, MTBookCriticalSectionTest) {
 
   class QueueUser : public base::DelegateSimpleThread::Delegate {
    public:
-    explicit QueueUser(NonThreadSafeQueue& queue)
-        : queue_(queue) {}
+    explicit QueueUser(NonThreadSafeQueue* queue) : queue_(queue) {}
 
     void Run() override {
-      queue_.push(0);
-      queue_.pop();
+      queue_->push(0);
+      queue_->pop();
     }
 
    private:
-    NonThreadSafeQueue& queue_;
+    NonThreadSafeQueue* queue_;
   };
 
   AssertReporter* local_reporter = new AssertReporter();
 
   NonThreadSafeQueue queue(local_reporter);
 
-  QueueUser queue_user_a(queue);
-  QueueUser queue_user_b(queue);
+  QueueUser queue_user_a(&queue);
+  QueueUser queue_user_b(&queue);
 
   base::DelegateSimpleThread thread_a(&queue_user_a, "queue_user_thread_a");
   base::DelegateSimpleThread thread_b(&queue_user_b, "queue_user_thread_b");
@@ -204,24 +203,23 @@ TEST(ThreadCollisionTest, MTScopedBookCriticalSectionTest) {
 
   class QueueUser : public base::DelegateSimpleThread::Delegate {
    public:
-    explicit QueueUser(NonThreadSafeQueue& queue)
-        : queue_(queue) {}
+    explicit QueueUser(NonThreadSafeQueue* queue) : queue_(queue) {}
 
     void Run() override {
-      queue_.push(0);
-      queue_.pop();
+      queue_->push(0);
+      queue_->pop();
     }
 
    private:
-    NonThreadSafeQueue& queue_;
+    NonThreadSafeQueue* queue_;
   };
 
   AssertReporter* local_reporter = new AssertReporter();
 
   NonThreadSafeQueue queue(local_reporter);
 
-  QueueUser queue_user_a(queue);
-  QueueUser queue_user_b(queue);
+  QueueUser queue_user_a(&queue);
+  QueueUser queue_user_b(&queue);
 
   base::DelegateSimpleThread thread_a(&queue_user_a, "queue_user_thread_a");
   base::DelegateSimpleThread thread_b(&queue_user_b, "queue_user_thread_b");
@@ -264,23 +262,22 @@ TEST(ThreadCollisionTest, MTSynchedScopedBookCriticalSectionTest) {
   // a lock.
   class QueueUser : public base::DelegateSimpleThread::Delegate {
    public:
-    QueueUser(NonThreadSafeQueue& queue, base::Lock& lock)
-        : queue_(queue),
-          lock_(lock) {}
+    QueueUser(NonThreadSafeQueue* queue, base::Lock* lock)
+        : queue_(queue), lock_(lock) {}
 
     void Run() override {
       {
-        base::AutoLock auto_lock(lock_);
-        queue_.push(0);
+        base::AutoLock auto_lock(*lock_);
+        queue_->push(0);
       }
       {
-        base::AutoLock auto_lock(lock_);
-        queue_.pop();
+        base::AutoLock auto_lock(*lock_);
+        queue_->pop();
       }
     }
    private:
-    NonThreadSafeQueue& queue_;
-    base::Lock& lock_;
+    NonThreadSafeQueue* queue_;
+    base::Lock* lock_;
   };
 
   AssertReporter* local_reporter = new AssertReporter();
@@ -289,8 +286,8 @@ TEST(ThreadCollisionTest, MTSynchedScopedBookCriticalSectionTest) {
 
   base::Lock lock;
 
-  QueueUser queue_user_a(queue, lock);
-  QueueUser queue_user_b(queue, lock);
+  QueueUser queue_user_a(&queue, &lock);
+  QueueUser queue_user_b(&queue, &lock);
 
   base::DelegateSimpleThread thread_a(&queue_user_a, "queue_user_thread_a");
   base::DelegateSimpleThread thread_b(&queue_user_b, "queue_user_thread_b");
@@ -338,27 +335,26 @@ TEST(ThreadCollisionTest, MTSynchedScopedRecursiveBookCriticalSectionTest) {
   // a lock.
   class QueueUser : public base::DelegateSimpleThread::Delegate {
    public:
-    QueueUser(NonThreadSafeQueue& queue, base::Lock& lock)
-        : queue_(queue),
-          lock_(lock) {}
+    QueueUser(NonThreadSafeQueue* queue, base::Lock* lock)
+        : queue_(queue), lock_(lock) {}
 
     void Run() override {
       {
-        base::AutoLock auto_lock(lock_);
-        queue_.push(0);
+        base::AutoLock auto_lock(*lock_);
+        queue_->push(0);
       }
       {
-        base::AutoLock auto_lock(lock_);
-        queue_.bar();
+        base::AutoLock auto_lock(*lock_);
+        queue_->bar();
       }
       {
-        base::AutoLock auto_lock(lock_);
-        queue_.pop();
+        base::AutoLock auto_lock(*lock_);
+        queue_->pop();
       }
     }
    private:
-    NonThreadSafeQueue& queue_;
-    base::Lock& lock_;
+    NonThreadSafeQueue* queue_;
+    base::Lock* lock_;
   };
 
   AssertReporter* local_reporter = new AssertReporter();
@@ -367,8 +363,8 @@ TEST(ThreadCollisionTest, MTSynchedScopedRecursiveBookCriticalSectionTest) {
 
   base::Lock lock;
 
-  QueueUser queue_user_a(queue, lock);
-  QueueUser queue_user_b(queue, lock);
+  QueueUser queue_user_a(&queue, &lock);
+  QueueUser queue_user_b(&queue, &lock);
 
   base::DelegateSimpleThread thread_a(&queue_user_a, "queue_user_thread_a");
   base::DelegateSimpleThread thread_b(&queue_user_b, "queue_user_thread_b");
diff --git a/base/trace_event/trace_event_impl.cc b/base/trace_event/trace_event_impl.cc
index bd0b57d..72b46f9 100644
--- a/base/trace_event/trace_event_impl.cc
+++ b/base/trace_event/trace_event_impl.cc
@@ -430,25 +430,22 @@ scoped_ptr<TraceBufferChunk> TraceBufferChunk::Clone() const {
 // and unlocks at the end of scope if locked.
 class TraceLog::OptionalAutoLock {
  public:
-  explicit OptionalAutoLock(Lock& lock)
-      : lock_(lock),
-        locked_(false) {
-  }
+  explicit OptionalAutoLock(Lock* lock) : lock_(lock), locked_(false) {}
 
   ~OptionalAutoLock() {
     if (locked_)
-      lock_.Release();
+      lock_->Release();
   }
 
   void EnsureAcquired() {
     if (!locked_) {
-      lock_.Acquire();
+      lock_->Acquire();
       locked_ = true;
     }
   }
 
  private:
-  Lock& lock_;
+  Lock* lock_;
   bool locked_;
   DISALLOW_COPY_AND_ASSIGN(OptionalAutoLock);
 };
@@ -1977,7 +1974,7 @@ TraceEventHandle TraceLog::AddTraceEventWithThreadIdAndTimestamp(
   std::string console_message;
   if (*category_group_enabled &
       (ENABLED_FOR_RECORDING | ENABLED_FOR_MONITORING)) {
-    OptionalAutoLock lock(lock_);
+    OptionalAutoLock lock(&lock_);
 
     TraceEvent* trace_event = NULL;
     if (thread_local_event_buffer) {
@@ -2130,7 +2127,7 @@ void TraceLog::UpdateTraceEventDuration(
 
   std::string console_message;
   if (*category_group_enabled & ENABLED_FOR_RECORDING) {
-    OptionalAutoLock lock(lock_);
+    OptionalAutoLock lock(&lock_);
 
     TraceEvent* trace_event = GetEventByHandleInternal(handle, &lock);
     if (trace_event) {