[Sync] Rename classes in sync/ that start with Chrome

sync/notifier/sync_system_resources_unittest.cc

Index: sync/notifier/sync_system_resources_unittest.cc
diff --git a/sync/notifier/chrome_system_resources_unittest.cc b/sync/notifier/sync_system_resources_unittest.cc
similarity index 67%
rename from sync/notifier/chrome_system_resources_unittest.cc
rename to sync/notifier/sync_system_resources_unittest.cc
index 7d05db8da10ab2e7ff242d6beda75ed810441d39..314f728605c8f9c257e777b7bc47d5d60e1e7774 100644
--- a/sync/notifier/chrome_system_resources_unittest.cc
+++ b/sync/notifier/sync_system_resources_unittest.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "sync/notifier/chrome_system_resources.h"
+#include "sync/notifier/sync_system_resources.h"
 
 #include <string>
 
@@ -46,14 +46,14 @@ class MockStorageCallback {
   }
 };
 
-class ChromeSystemResourcesTest : public testing::Test {
+class SyncSystemResourcesTest : public testing::Test {
  protected:
-  ChromeSystemResourcesTest()
-      : chrome_system_resources_(
+  SyncSystemResourcesTest()
+      : sync_system_resources_(
           scoped_ptr<notifier::PushClient>(new notifier::FakePushClient()),
           &mock_state_writer_) {}
 
-  virtual ~ChromeSystemResourcesTest() {}
+  virtual ~SyncSystemResourcesTest() {}
 
   void ScheduleShouldNotRun() {
     {
@@ -61,7 +61,7 @@ class ChromeSystemResourcesTest : public testing::Test {
       MockClosure mock_closure;
       base::Closure* should_not_run = mock_closure.CreateClosure();
       EXPECT_CALL(mock_closure, Run()).Times(0);
-      chrome_system_resources_.internal_scheduler()->Schedule(
+      sync_system_resources_.internal_scheduler()->Schedule(
           invalidation::Scheduler::NoDelay(), should_not_run);
     }
     {
@@ -69,7 +69,7 @@ class ChromeSystemResourcesTest : public testing::Test {
       MockClosure mock_closure;
       base::Closure* should_not_run = mock_closure.CreateClosure();
       EXPECT_CALL(mock_closure, Run()).Times(0);
-      chrome_system_resources_.listener_scheduler()->Schedule(
+      sync_system_resources_.listener_scheduler()->Schedule(
           invalidation::Scheduler::NoDelay(), should_not_run);
     }
     {
@@ -77,89 +77,89 @@ class ChromeSystemResourcesTest : public testing::Test {
       MockClosure mock_closure;
       base::Closure* should_not_run = mock_closure.CreateClosure();
       EXPECT_CALL(mock_closure, Run()).Times(0);
-      chrome_system_resources_.internal_scheduler()->Schedule(
+      sync_system_resources_.internal_scheduler()->Schedule(
           invalidation::TimeDelta::FromSeconds(0), should_not_run);
     }
   }
 
-  // Needed by |chrome_system_resources_|.
+  // Needed by |sync_system_resources_|.
   MessageLoop message_loop_;
   MockStateWriter mock_state_writer_;
-  ChromeSystemResources chrome_system_resources_;
+  SyncSystemResources sync_system_resources_;
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(ChromeSystemResourcesTest);
+  DISALLOW_COPY_AND_ASSIGN(SyncSystemResourcesTest);
 };
 
 // Make sure current_time() doesn't crash or leak.
-TEST_F(ChromeSystemResourcesTest, CurrentTime) {
+TEST_F(SyncSystemResourcesTest, CurrentTime) {
   invalidation::Time current_time =
-      chrome_system_resources_.internal_scheduler()->GetCurrentTime();
+      sync_system_resources_.internal_scheduler()->GetCurrentTime();
   DVLOG(1) << "current_time returned: " << current_time.ToInternalValue();
 }
 
 // Make sure Log() doesn't crash or leak.
-TEST_F(ChromeSystemResourcesTest, Log) {
-  chrome_system_resources_.logger()->Log(ChromeLogger::INFO_LEVEL,
+TEST_F(SyncSystemResourcesTest, Log) {
+  sync_system_resources_.logger()->Log(SyncLogger::INFO_LEVEL,
                                          __FILE__, __LINE__, "%s %d",
                                          "test string", 5);
 }
 
-TEST_F(ChromeSystemResourcesTest, ScheduleBeforeStart) {
+TEST_F(SyncSystemResourcesTest, ScheduleBeforeStart) {
   ScheduleShouldNotRun();
-  chrome_system_resources_.Start();
+  sync_system_resources_.Start();
 }
 
-TEST_F(ChromeSystemResourcesTest, ScheduleAfterStop) {
-  chrome_system_resources_.Start();
-  chrome_system_resources_.Stop();
+TEST_F(SyncSystemResourcesTest, ScheduleAfterStop) {
+  sync_system_resources_.Start();
+  sync_system_resources_.Stop();
   ScheduleShouldNotRun();
 }
 
-TEST_F(ChromeSystemResourcesTest, ScheduleAndStop) {
-  chrome_system_resources_.Start();
+TEST_F(SyncSystemResourcesTest, ScheduleAndStop) {
+  sync_system_resources_.Start();
   ScheduleShouldNotRun();
-  chrome_system_resources_.Stop();
+  sync_system_resources_.Stop();
 }
 
-TEST_F(ChromeSystemResourcesTest, ScheduleAndDestroy) {
-  chrome_system_resources_.Start();
+TEST_F(SyncSystemResourcesTest, ScheduleAndDestroy) {
+  sync_system_resources_.Start();
   ScheduleShouldNotRun();
 }
 
-TEST_F(ChromeSystemResourcesTest, ScheduleImmediately) {
-  chrome_system_resources_.Start();
+TEST_F(SyncSystemResourcesTest, ScheduleImmediately) {
+  sync_system_resources_.Start();
   MockClosure mock_closure;
   EXPECT_CALL(mock_closure, Run());
-  chrome_system_resources_.internal_scheduler()->Schedule(
+  sync_system_resources_.internal_scheduler()->Schedule(
       invalidation::Scheduler::NoDelay(), mock_closure.CreateClosure());
   message_loop_.RunAllPending();
 }
 
-TEST_F(ChromeSystemResourcesTest, ScheduleOnListenerThread) {
-  chrome_system_resources_.Start();
+TEST_F(SyncSystemResourcesTest, ScheduleOnListenerThread) {
+  sync_system_resources_.Start();
   MockClosure mock_closure;
   EXPECT_CALL(mock_closure, Run());
-  chrome_system_resources_.listener_scheduler()->Schedule(
+  sync_system_resources_.listener_scheduler()->Schedule(
       invalidation::Scheduler::NoDelay(), mock_closure.CreateClosure());
   EXPECT_TRUE(
-      chrome_system_resources_.internal_scheduler()->IsRunningOnThread());
+      sync_system_resources_.internal_scheduler()->IsRunningOnThread());
   message_loop_.RunAllPending();
 }
 
-TEST_F(ChromeSystemResourcesTest, ScheduleWithZeroDelay) {
-  chrome_system_resources_.Start();
+TEST_F(SyncSystemResourcesTest, ScheduleWithZeroDelay) {
+  sync_system_resources_.Start();
   MockClosure mock_closure;
   EXPECT_CALL(mock_closure, Run());
-  chrome_system_resources_.internal_scheduler()->Schedule(
+  sync_system_resources_.internal_scheduler()->Schedule(
       invalidation::TimeDelta::FromSeconds(0), mock_closure.CreateClosure());
   message_loop_.RunAllPending();
 }
 
 // TODO(akalin): Figure out how to test with a non-zero delay.
 
-TEST_F(ChromeSystemResourcesTest, WriteState) {
-  chrome_system_resources_.Start();
+TEST_F(SyncSystemResourcesTest, WriteState) {
+  sync_system_resources_.Start();
   EXPECT_CALL(mock_state_writer_, WriteState(_));
   // Owned by WriteState.
   MockStorageCallback mock_storage_callback;
@@ -167,7 +167,7 @@ TEST_F(ChromeSystemResourcesTest, WriteState) {
                                "fake-failure");
   EXPECT_CALL(mock_storage_callback, Run(_))
       .WillOnce(SaveArg<0>(&results));
-  chrome_system_resources_.storage()->WriteKey(
+  sync_system_resources_.storage()->WriteKey(
       "", "state", mock_storage_callback.CreateCallback());
   message_loop_.RunAllPending();
   EXPECT_EQ(invalidation::Status(invalidation::Status::SUCCESS, ""), results);