diff --git a/libweave.gypi b/libweave.gypi
index b529add..6f64c89 100644
--- a/libweave.gypi
+++ b/libweave.gypi
@@ -115,6 +115,7 @@
       'third_party/chromium/base/third_party/dmg_fp/dtoa.cc',
       'third_party/chromium/base/third_party/icu/icu_utf.cc',
       'third_party/chromium/base/time/clock.cc',
+      'third_party/chromium/base/time/default_clock.cc',
       'third_party/chromium/base/time/time.cc',
       'third_party/chromium/base/time/time_posix.cc',
       'third_party/chromium/base/values.cc',
diff --git a/src/base_api_handler_unittest.cc b/src/base_api_handler_unittest.cc
index ca47626..14421b0 100644
--- a/src/base_api_handler_unittest.cc
+++ b/src/base_api_handler_unittest.cc
@@ -5,6 +5,7 @@
 #include "src/base_api_handler.h"
 
 #include <base/strings/string_number_conversions.h>
+#include <base/time/default_clock.h>
 #include <base/values.h>
 #include <gtest/gtest.h>
 #include <weave/provider/test/mock_config_store.h>
diff --git a/src/component_manager_impl.cc b/src/component_manager_impl.cc
index a23f34d..89ca0cd 100644
--- a/src/component_manager_impl.cc
+++ b/src/component_manager_impl.cc
@@ -31,10 +31,8 @@
 LIBWEAVE_EXPORT EnumToStringMap<UserRole>::EnumToStringMap()
     : EnumToStringMap(kMap) {}
 
-ComponentManagerImpl::ComponentManagerImpl() {}
-
-ComponentManagerImpl::ComponentManagerImpl(base::Clock* clock) : clock_{clock} {
-}
+ComponentManagerImpl::ComponentManagerImpl(base::Clock* clock)
+    : clock_{clock ? clock : &default_clock_} {}
 
 ComponentManagerImpl::~ComponentManagerImpl() {}
 
@@ -343,7 +341,7 @@
   auto& queue = state_change_queues_[component_path];
   if (!queue)
     queue.reset(new StateChangeQueue{kMaxStateChangeQueueSize});
-  base::Time timestamp = clock_ ? clock_->Now() : base::Time::Now();
+  base::Time timestamp = clock_->Now();
   queue->NotifyPropertiesUpdated(timestamp, dict);
   for (const auto& cb : on_state_changed_)
     cb.Run();
diff --git a/src/component_manager_impl.h b/src/component_manager_impl.h
index c59c6d9..426b4b0 100644
--- a/src/component_manager_impl.h
+++ b/src/component_manager_impl.h
@@ -5,6 +5,8 @@
 #ifndef LIBWEAVE_SRC_COMPONENT_MANAGER_IMPL_H_
 #define LIBWEAVE_SRC_COMPONENT_MANAGER_IMPL_H_
 
+#include <base/time/default_clock.h>
+
 #include "src/commands/command_queue.h"
 #include "src/component_manager.h"
 #include "src/states/state_change_queue.h"
@@ -13,8 +15,7 @@
 
 class ComponentManagerImpl final : public ComponentManager {
  public:
-  ComponentManagerImpl();
-  explicit ComponentManagerImpl(base::Clock* clock);
+  explicit ComponentManagerImpl(base::Clock* clock = nullptr);
   ~ComponentManagerImpl() override;
 
   // Loads trait definition schema.
@@ -188,6 +189,7 @@
       const std::string& path,
       ErrorPtr* error);
 
+  base::DefaultClock default_clock_;
   base::Clock* clock_{nullptr};
   // An ID of last state change update. Each NotifyPropertiesUpdated()
   // invocation increments this value by 1.
diff --git a/src/component_manager_unittest.cc b/src/component_manager_unittest.cc
index 902ee15..c63d2dd 100644
--- a/src/component_manager_unittest.cc
+++ b/src/component_manager_unittest.cc
@@ -12,10 +12,12 @@
 #include "src/bind_lambda.h"
 #include "src/commands/schema_constants.h"
 #include "src/mock_component_manager.h"
+#include "src/test/mock_clock.h"
 
 namespace weave {
 
 using test::CreateDictionaryValue;
+using testing::Return;
 
 namespace {
 
@@ -65,47 +67,36 @@
 //     }
 //   }
 // }
-void CreateTestComponentTree(ComponentManager* manager) {
-  const char kTraits[] = R"({"t1":{},"t2":{},"t3":{},"t4":{},"t5":{},"t6":{}})";
-  auto json = CreateDictionaryValue(kTraits);
-  ASSERT_TRUE(manager->LoadTraits(*json, nullptr));
-  EXPECT_TRUE(manager->AddComponent("", "comp1", {"t1"}, nullptr));
-  EXPECT_TRUE(manager->AddComponentArrayItem("comp1", "comp2", {"t2"},
-                                             nullptr));
-  EXPECT_TRUE(manager->AddComponentArrayItem("comp1", "comp2", {"t3"},
-                                             nullptr));
-  EXPECT_TRUE(manager->AddComponent("comp1.comp2[1]", "comp3", {"t4"},
-                                    nullptr));
-  EXPECT_TRUE(manager->AddComponent("comp1.comp2[1].comp3", "comp4",
-                                    {"t5", "t6"}, nullptr));
-}
+class ComponentManagerTest : public ::testing::Test {
+ protected:
+  void CreateTestComponentTree(ComponentManager* manager) {
+    const char kTraits[] =
+        R"({"t1":{},"t2":{},"t3":{},"t4":{},"t5":{},"t6":{}})";
+    auto json = CreateDictionaryValue(kTraits);
+    ASSERT_TRUE(manager->LoadTraits(*json, nullptr));
+    EXPECT_TRUE(manager->AddComponent("", "comp1", {"t1"}, nullptr));
+    EXPECT_TRUE(
+        manager->AddComponentArrayItem("comp1", "comp2", {"t2"}, nullptr));
+    EXPECT_TRUE(
+        manager->AddComponentArrayItem("comp1", "comp2", {"t3"}, nullptr));
+    EXPECT_TRUE(
+        manager->AddComponent("comp1.comp2[1]", "comp3", {"t4"}, nullptr));
+    EXPECT_TRUE(manager->AddComponent("comp1.comp2[1].comp3", "comp4",
+                                      {"t5", "t6"}, nullptr));
+  }
 
-// Test clock class to record predefined time intervals.
-// Implementation from base/test/simple_test_clock.{h|cc}
-class SimpleTestClock : public base::Clock {
- public:
-  base::Time Now() override { return now_; }
-
-  // Advances the clock by |delta|.
-  void Advance(base::TimeDelta delta) { now_ += delta; }
-
-  // Sets the clock to the given time.
-  void SetNow(base::Time now) { now_ = now; }
-
- private:
-  base::Time now_;
+  test::MockClock clock_;
+  ComponentManagerImpl manager_{&clock_};
 };
 
 }  // anonymous namespace
 
-TEST(ComponentManager, Empty) {
-  ComponentManagerImpl manager;
-  EXPECT_TRUE(manager.GetTraits().empty());
-  EXPECT_TRUE(manager.GetComponents().empty());
+TEST_F(ComponentManagerTest, Empty) {
+  EXPECT_TRUE(manager_.GetTraits().empty());
+  EXPECT_TRUE(manager_.GetComponents().empty());
 }
 
-TEST(ComponentManager, LoadTraits) {
-  ComponentManagerImpl manager;
+TEST_F(ComponentManagerTest, LoadTraits) {
   const char kTraits[] = R"({
     "trait1": {
       "commands": {
@@ -125,13 +116,12 @@
     }
   })";
   auto json = CreateDictionaryValue(kTraits);
-  EXPECT_TRUE(manager.LoadTraits(*json, nullptr));
-  EXPECT_JSON_EQ(kTraits, manager.GetTraits());
-  EXPECT_TRUE(manager.GetComponents().empty());
+  EXPECT_TRUE(manager_.LoadTraits(*json, nullptr));
+  EXPECT_JSON_EQ(kTraits, manager_.GetTraits());
+  EXPECT_TRUE(manager_.GetComponents().empty());
 }
 
-TEST(ComponentManager, LoadTraitsDuplicateIdentical) {
-  ComponentManagerImpl manager;
+TEST_F(ComponentManagerTest, LoadTraitsDuplicateIdentical) {
   const char kTraits1[] = R"({
     "trait1": {
       "commands": {
@@ -151,7 +141,7 @@
     }
   })";
   auto json = CreateDictionaryValue(kTraits1);
-  EXPECT_TRUE(manager.LoadTraits(*json, nullptr));
+  EXPECT_TRUE(manager_.LoadTraits(*json, nullptr));
   const char kTraits2[] = R"({
     "trait1": {
       "commands": {
@@ -171,7 +161,7 @@
     }
   })";
   json = CreateDictionaryValue(kTraits2);
-  EXPECT_TRUE(manager.LoadTraits(*json, nullptr));
+  EXPECT_TRUE(manager_.LoadTraits(*json, nullptr));
   const char kExpected[] = R"({
     "trait1": {
       "commands": {
@@ -195,11 +185,10 @@
       }
     }
   })";
-  EXPECT_JSON_EQ(kExpected, manager.GetTraits());
+  EXPECT_JSON_EQ(kExpected, manager_.GetTraits());
 }
 
-TEST(ComponentManager, LoadTraitsDuplicateOverride) {
-  ComponentManagerImpl manager;
+TEST_F(ComponentManagerTest, LoadTraitsDuplicateOverride) {
   const char kTraits1[] = R"({
     "trait1": {
       "commands": {
@@ -219,7 +208,7 @@
     }
   })";
   auto json = CreateDictionaryValue(kTraits1);
-  EXPECT_TRUE(manager.LoadTraits(*json, nullptr));
+  EXPECT_TRUE(manager_.LoadTraits(*json, nullptr));
   const char kTraits2[] = R"({
     "trait1": {
       "commands": {
@@ -239,15 +228,14 @@
     }
   })";
   json = CreateDictionaryValue(kTraits2);
-  EXPECT_FALSE(manager.LoadTraits(*json, nullptr));
+  EXPECT_FALSE(manager_.LoadTraits(*json, nullptr));
 }
 
-TEST(ComponentManager, AddTraitDefChangedCallback) {
-  ComponentManagerImpl manager;
+TEST_F(ComponentManagerTest, AddTraitDefChangedCallback) {
   int count = 0;
   int count2 = 0;
-  manager.AddTraitDefChangedCallback(base::Bind([&count]() { count++; }));
-  manager.AddTraitDefChangedCallback(base::Bind([&count2]() { count2++; }));
+  manager_.AddTraitDefChangedCallback(base::Bind([&count]() { count++; }));
+  manager_.AddTraitDefChangedCallback(base::Bind([&count2]() { count2++; }));
   EXPECT_EQ(1, count);
   EXPECT_EQ(1, count2);
   // New definitions.
@@ -264,7 +252,7 @@
     }
   })";
   auto json = CreateDictionaryValue(kTraits1);
-  EXPECT_TRUE(manager.LoadTraits(*json, nullptr));
+  EXPECT_TRUE(manager_.LoadTraits(*json, nullptr));
   EXPECT_EQ(2, count);
   // Duplicate definition, shouldn't call the callback.
   const char kTraits2[] = R"({
@@ -275,7 +263,7 @@
     }
   })";
   json = CreateDictionaryValue(kTraits2);
-  EXPECT_TRUE(manager.LoadTraits(*json, nullptr));
+  EXPECT_TRUE(manager_.LoadTraits(*json, nullptr));
   EXPECT_EQ(2, count);
   // New definition, should call the callback now.
   const char kTraits3[] = R"({
@@ -286,30 +274,28 @@
     }
   })";
   json = CreateDictionaryValue(kTraits3);
-  EXPECT_TRUE(manager.LoadTraits(*json, nullptr));
+  EXPECT_TRUE(manager_.LoadTraits(*json, nullptr));
   EXPECT_EQ(3, count);
   // Wrong definition, shouldn't call the callback.
   const char kTraits4[] = R"({
     "trait4": "foo"
   })";
   json = CreateDictionaryValue(kTraits4);
-  EXPECT_FALSE(manager.LoadTraits(*json, nullptr));
+  EXPECT_FALSE(manager_.LoadTraits(*json, nullptr));
   EXPECT_EQ(3, count);
   // Make sure both callbacks were called the same number of times.
   EXPECT_EQ(count2, count);
 }
 
-TEST(ComponentManager, LoadTraitsNotAnObject) {
-  ComponentManagerImpl manager;
+TEST_F(ComponentManagerTest, LoadTraitsNotAnObject) {
   const char kTraits1[] = R"({"trait1": 0})";
   auto json = CreateDictionaryValue(kTraits1);
   ErrorPtr error;
-  EXPECT_FALSE(manager.LoadTraits(*json, &error));
+  EXPECT_FALSE(manager_.LoadTraits(*json, &error));
   EXPECT_EQ(errors::commands::kTypeMismatch, error->GetCode());
 }
 
-TEST(ComponentManager, FindTraitDefinition) {
-  ComponentManagerImpl manager;
+TEST_F(ComponentManagerTest, FindTraitDefinition) {
   const char kTraits[] = R"({
     "trait1": {
       "commands": {
@@ -329,9 +315,9 @@
     }
   })";
   auto json = CreateDictionaryValue(kTraits);
-  ASSERT_TRUE(manager.LoadTraits(*json, nullptr));
+  ASSERT_TRUE(manager_.LoadTraits(*json, nullptr));
 
-  const base::DictionaryValue* trait = manager.FindTraitDefinition("trait1");
+  const base::DictionaryValue* trait = manager_.FindTraitDefinition("trait1");
   ASSERT_NE(nullptr, trait);
   const char kExpected1[] = R"({
     "commands": {
@@ -346,7 +332,7 @@
   })";
   EXPECT_JSON_EQ(kExpected1, *trait);
 
-  trait = manager.FindTraitDefinition("trait2");
+  trait = manager_.FindTraitDefinition("trait2");
   ASSERT_NE(nullptr, trait);
   const char kExpected2[] = R"({
     "state": {
@@ -355,11 +341,10 @@
   })";
   EXPECT_JSON_EQ(kExpected2, *trait);
 
-  EXPECT_EQ(nullptr, manager.FindTraitDefinition("trait3"));
+  EXPECT_EQ(nullptr, manager_.FindTraitDefinition("trait3"));
 }
 
-TEST(ComponentManager, FindCommandDefinition) {
-  ComponentManagerImpl manager;
+TEST_F(ComponentManagerTest, FindCommandDefinition) {
   const char kTraits[] = R"({
     "trait1": {
       "commands": {
@@ -381,9 +366,9 @@
     }
   })";
   auto json = CreateDictionaryValue(kTraits);
-  ASSERT_TRUE(manager.LoadTraits(*json, nullptr));
+  ASSERT_TRUE(manager_.LoadTraits(*json, nullptr));
 
-  const auto* cmd_def = manager.FindCommandDefinition("trait1.command1");
+  const auto* cmd_def = manager_.FindCommandDefinition("trait1.command1");
   ASSERT_NE(nullptr, cmd_def);
   const char kExpected1[] = R"({
     "minimalRole": "user",
@@ -391,28 +376,28 @@
   })";
   EXPECT_JSON_EQ(kExpected1, *cmd_def);
 
-  cmd_def = manager.FindCommandDefinition("trait2.command1");
+  cmd_def = manager_.FindCommandDefinition("trait2.command1");
   ASSERT_NE(nullptr, cmd_def);
   const char kExpected2[] = R"({
     "minimalRole": "manager"
   })";
   EXPECT_JSON_EQ(kExpected2, *cmd_def);
 
-  cmd_def = manager.FindCommandDefinition("trait2.command2");
+  cmd_def = manager_.FindCommandDefinition("trait2.command2");
   ASSERT_NE(nullptr, cmd_def);
   const char kExpected3[] = R"({
     "minimalRole": "owner"
   })";
   EXPECT_JSON_EQ(kExpected3, *cmd_def);
 
-  EXPECT_EQ(nullptr, manager.FindTraitDefinition("trait1.command2"));
-  EXPECT_EQ(nullptr, manager.FindTraitDefinition("trait3.command1"));
-  EXPECT_EQ(nullptr, manager.FindTraitDefinition("trait"));
-  EXPECT_EQ(nullptr, manager.FindTraitDefinition("trait1.command1.parameters"));
+  EXPECT_EQ(nullptr, manager_.FindTraitDefinition("trait1.command2"));
+  EXPECT_EQ(nullptr, manager_.FindTraitDefinition("trait3.command1"));
+  EXPECT_EQ(nullptr, manager_.FindTraitDefinition("trait"));
+  EXPECT_EQ(nullptr,
+            manager_.FindTraitDefinition("trait1.command1.parameters"));
 }
 
-TEST(ComponentManager, GetMinimalRole) {
-  ComponentManagerImpl manager;
+TEST_F(ComponentManagerTest, GetMinimalRole) {
   const char kTraits[] = R"({
     "trait1": {
       "commands": {
@@ -428,31 +413,31 @@
     }
   })";
   auto json = CreateDictionaryValue(kTraits);
-  ASSERT_TRUE(manager.LoadTraits(*json, nullptr));
+  ASSERT_TRUE(manager_.LoadTraits(*json, nullptr));
 
   UserRole role;
-  ASSERT_TRUE(manager.GetMinimalRole("trait1.command1", &role, nullptr));
+  ASSERT_TRUE(manager_.GetMinimalRole("trait1.command1", &role, nullptr));
   EXPECT_EQ(UserRole::kUser, role);
 
-  ASSERT_TRUE(manager.GetMinimalRole("trait1.command2", &role, nullptr));
+  ASSERT_TRUE(manager_.GetMinimalRole("trait1.command2", &role, nullptr));
   EXPECT_EQ(UserRole::kViewer, role);
 
-  ASSERT_TRUE(manager.GetMinimalRole("trait2.command1", &role, nullptr));
+  ASSERT_TRUE(manager_.GetMinimalRole("trait2.command1", &role, nullptr));
   EXPECT_EQ(UserRole::kManager, role);
 
-  ASSERT_TRUE(manager.GetMinimalRole("trait2.command2", &role, nullptr));
+  ASSERT_TRUE(manager_.GetMinimalRole("trait2.command2", &role, nullptr));
   EXPECT_EQ(UserRole::kOwner, role);
 
-  EXPECT_FALSE(manager.GetMinimalRole("trait1.command3", &role, nullptr));
+  EXPECT_FALSE(manager_.GetMinimalRole("trait1.command3", &role, nullptr));
 }
 
-TEST(ComponentManager, AddComponent) {
-  ComponentManagerImpl manager;
+TEST_F(ComponentManagerTest, AddComponent) {
   const char kTraits[] = R"({"trait1": {}, "trait2": {}, "trait3": {}})";
   auto json = CreateDictionaryValue(kTraits);
-  ASSERT_TRUE(manager.LoadTraits(*json, nullptr));
-  EXPECT_TRUE(manager.AddComponent("", "comp1", {"trait1", "trait2"}, nullptr));
-  EXPECT_TRUE(manager.AddComponent("", "comp2", {"trait3"}, nullptr));
+  ASSERT_TRUE(manager_.LoadTraits(*json, nullptr));
+  EXPECT_TRUE(
+      manager_.AddComponent("", "comp1", {"trait1", "trait2"}, nullptr));
+  EXPECT_TRUE(manager_.AddComponent("", "comp2", {"trait3"}, nullptr));
   const char kExpected[] = R"({
     "comp1": {
       "traits": ["trait1", "trait2"]
@@ -461,18 +446,17 @@
       "traits": ["trait3"]
     }
   })";
-  EXPECT_JSON_EQ(kExpected, manager.GetComponents());
+  EXPECT_JSON_EQ(kExpected, manager_.GetComponents());
 
   // 'trait4' is undefined, so can't add a component referring to it.
-  EXPECT_FALSE(manager.AddComponent("", "comp3", {"trait4"}, nullptr));
+  EXPECT_FALSE(manager_.AddComponent("", "comp3", {"trait4"}, nullptr));
 }
 
-TEST(ComponentManager, AddSubComponent) {
-  ComponentManagerImpl manager;
-  EXPECT_TRUE(manager.AddComponent("", "comp1", {}, nullptr));
-  EXPECT_TRUE(manager.AddComponent("comp1", "comp2", {}, nullptr));
-  EXPECT_TRUE(manager.AddComponent("comp1", "comp3", {}, nullptr));
-  EXPECT_TRUE(manager.AddComponent("comp1.comp2", "comp4", {}, nullptr));
+TEST_F(ComponentManagerTest, AddSubComponent) {
+  EXPECT_TRUE(manager_.AddComponent("", "comp1", {}, nullptr));
+  EXPECT_TRUE(manager_.AddComponent("comp1", "comp2", {}, nullptr));
+  EXPECT_TRUE(manager_.AddComponent("comp1", "comp3", {}, nullptr));
+  EXPECT_TRUE(manager_.AddComponent("comp1.comp2", "comp4", {}, nullptr));
   const char kExpected[] = R"({
     "comp1": {
       "traits": [],
@@ -491,23 +475,22 @@
       }
     }
   })";
-  EXPECT_JSON_EQ(kExpected, manager.GetComponents());
+  EXPECT_JSON_EQ(kExpected, manager_.GetComponents());
 }
 
-TEST(ComponentManager, AddComponentArrayItem) {
-  ComponentManagerImpl manager;
+TEST_F(ComponentManagerTest, AddComponentArrayItem) {
   const char kTraits[] = R"({"foo": {}, "bar": {}})";
   auto json = CreateDictionaryValue(kTraits);
-  ASSERT_TRUE(manager.LoadTraits(*json, nullptr));
+  ASSERT_TRUE(manager_.LoadTraits(*json, nullptr));
 
-  EXPECT_TRUE(manager.AddComponent("", "comp1", {}, nullptr));
-  EXPECT_TRUE(manager.AddComponentArrayItem("comp1", "comp2", {"foo"},
-                                            nullptr));
-  EXPECT_TRUE(manager.AddComponentArrayItem("comp1", "comp2", {"bar"},
-                                            nullptr));
-  EXPECT_TRUE(manager.AddComponent("comp1.comp2[1]", "comp3", {}, nullptr));
-  EXPECT_TRUE(manager.AddComponent("comp1.comp2[1].comp3", "comp4", {},
-                                   nullptr));
+  EXPECT_TRUE(manager_.AddComponent("", "comp1", {}, nullptr));
+  EXPECT_TRUE(
+      manager_.AddComponentArrayItem("comp1", "comp2", {"foo"}, nullptr));
+  EXPECT_TRUE(
+      manager_.AddComponentArrayItem("comp1", "comp2", {"bar"}, nullptr));
+  EXPECT_TRUE(manager_.AddComponent("comp1.comp2[1]", "comp3", {}, nullptr));
+  EXPECT_TRUE(
+      manager_.AddComponent("comp1.comp2[1].comp3", "comp4", {}, nullptr));
   const char kExpected[] = R"({
     "comp1": {
       "traits": [],
@@ -533,96 +516,91 @@
       }
     }
   })";
-  EXPECT_JSON_EQ(kExpected, manager.GetComponents());
+  EXPECT_JSON_EQ(kExpected, manager_.GetComponents());
 }
 
-TEST(ComponentManager, AddComponentExist) {
-  ComponentManagerImpl manager;
-  EXPECT_TRUE(manager.AddComponent("", "comp1", {}, nullptr));
-  EXPECT_FALSE(manager.AddComponent("", "comp1", {}, nullptr));
-  EXPECT_TRUE(manager.AddComponent("comp1", "comp2", {}, nullptr));
-  EXPECT_FALSE(manager.AddComponent("comp1", "comp2", {}, nullptr));
+TEST_F(ComponentManagerTest, AddComponentExist) {
+  EXPECT_TRUE(manager_.AddComponent("", "comp1", {}, nullptr));
+  EXPECT_FALSE(manager_.AddComponent("", "comp1", {}, nullptr));
+  EXPECT_TRUE(manager_.AddComponent("comp1", "comp2", {}, nullptr));
+  EXPECT_FALSE(manager_.AddComponent("comp1", "comp2", {}, nullptr));
 }
 
-TEST(ComponentManager, AddComponentDoesNotExist) {
-  ComponentManagerImpl manager;
-  EXPECT_FALSE(manager.AddComponent("comp1", "comp2", {}, nullptr));
+TEST_F(ComponentManagerTest, AddComponentDoesNotExist) {
+  EXPECT_FALSE(manager_.AddComponent("comp1", "comp2", {}, nullptr));
 }
 
-TEST(ComponentManager, AddComponentTreeChangedCallback) {
-  ComponentManagerImpl manager;
+TEST_F(ComponentManagerTest, AddComponentTreeChangedCallback) {
   int count = 0;
   int count2 = 0;
-  manager.AddComponentTreeChangedCallback(base::Bind([&count]() { count++; }));
-  manager.AddComponentTreeChangedCallback(
+  manager_.AddComponentTreeChangedCallback(base::Bind([&count]() { count++; }));
+  manager_.AddComponentTreeChangedCallback(
       base::Bind([&count2]() { count2++; }));
   EXPECT_EQ(1, count);
   EXPECT_EQ(1, count2);
-  EXPECT_TRUE(manager.AddComponent("", "comp1", {}, nullptr));
+  EXPECT_TRUE(manager_.AddComponent("", "comp1", {}, nullptr));
   EXPECT_EQ(2, count);
-  EXPECT_TRUE(manager.AddComponent("comp1", "comp2", {}, nullptr));
+  EXPECT_TRUE(manager_.AddComponent("comp1", "comp2", {}, nullptr));
   EXPECT_EQ(3, count);
-  EXPECT_TRUE(manager.AddComponent("comp1.comp2", "comp4", {}, nullptr));
+  EXPECT_TRUE(manager_.AddComponent("comp1.comp2", "comp4", {}, nullptr));
   EXPECT_EQ(4, count);
-  EXPECT_TRUE(manager.AddComponentArrayItem("comp1", "comp3", {}, nullptr));
+  EXPECT_TRUE(manager_.AddComponentArrayItem("comp1", "comp3", {}, nullptr));
   EXPECT_EQ(5, count);
-  EXPECT_TRUE(manager.AddComponentArrayItem("comp1", "comp3", {}, nullptr));
+  EXPECT_TRUE(manager_.AddComponentArrayItem("comp1", "comp3", {}, nullptr));
   EXPECT_EQ(6, count);
   // Make sure both callbacks were called the same number of times.
   EXPECT_EQ(count2, count);
 }
 
-TEST(ComponentManager, FindComponent) {
-  ComponentManagerImpl manager;
-  CreateTestComponentTree(&manager);
+TEST_F(ComponentManagerTest, FindComponent) {
+  CreateTestComponentTree(&manager_);
 
-  const base::DictionaryValue* comp = manager.FindComponent("comp1", nullptr);
+  const base::DictionaryValue* comp = manager_.FindComponent("comp1", nullptr);
   ASSERT_NE(nullptr, comp);
   EXPECT_TRUE(HasTrait(*comp, "t1"));
 
-  comp = manager.FindComponent("comp1.comp2[0]", nullptr);
+  comp = manager_.FindComponent("comp1.comp2[0]", nullptr);
   ASSERT_NE(nullptr, comp);
   EXPECT_TRUE(HasTrait(*comp, "t2"));
 
-  comp = manager.FindComponent("comp1.comp2[1]", nullptr);
+  comp = manager_.FindComponent("comp1.comp2[1]", nullptr);
   ASSERT_NE(nullptr, comp);
   EXPECT_TRUE(HasTrait(*comp, "t3"));
 
-  comp = manager.FindComponent("comp1.comp2[1].comp3", nullptr);
+  comp = manager_.FindComponent("comp1.comp2[1].comp3", nullptr);
   ASSERT_NE(nullptr, comp);
   EXPECT_TRUE(HasTrait(*comp, "t4"));
 
-  comp = manager.FindComponent("comp1.comp2[1].comp3.comp4", nullptr);
+  comp = manager_.FindComponent("comp1.comp2[1].comp3.comp4", nullptr);
   ASSERT_NE(nullptr, comp);
   EXPECT_TRUE(HasTrait(*comp, "t5"));
 
   // Some whitespaces don't hurt.
-  comp = manager.FindComponent(" comp1 . comp2 [  \t 1 ] .   comp3.comp4 ",
-                               nullptr);
+  comp = manager_.FindComponent(" comp1 . comp2 [  \t 1 ] .   comp3.comp4 ",
+                                nullptr);
   EXPECT_NE(nullptr, comp);
 
   // Now check some failure cases.
   ErrorPtr error;
-  EXPECT_EQ(nullptr, manager.FindComponent("", &error));
+  EXPECT_EQ(nullptr, manager_.FindComponent("", &error));
   EXPECT_NE(nullptr, error.get());
   // 'comp2' doesn't exist:
-  EXPECT_EQ(nullptr, manager.FindComponent("comp2", nullptr));
+  EXPECT_EQ(nullptr, manager_.FindComponent("comp2", nullptr));
   // 'comp1.comp2' is an array, not a component:
-  EXPECT_EQ(nullptr, manager.FindComponent("comp1.comp2", nullptr));
+  EXPECT_EQ(nullptr, manager_.FindComponent("comp1.comp2", nullptr));
   // 'comp1.comp2[3]' doesn't exist:
-  EXPECT_EQ(nullptr, manager.FindComponent("comp1.comp2[3]", nullptr));
+  EXPECT_EQ(nullptr, manager_.FindComponent("comp1.comp2[3]", nullptr));
   // Empty component names:
-  EXPECT_EQ(nullptr, manager.FindComponent(".comp2[1]", nullptr));
-  EXPECT_EQ(nullptr, manager.FindComponent("comp1.[1]", nullptr));
+  EXPECT_EQ(nullptr, manager_.FindComponent(".comp2[1]", nullptr));
+  EXPECT_EQ(nullptr, manager_.FindComponent("comp1.[1]", nullptr));
   // Invalid array indices:
-  EXPECT_EQ(nullptr, manager.FindComponent("comp1.comp2[s]", nullptr));
-  EXPECT_EQ(nullptr, manager.FindComponent("comp1.comp2[-2]", nullptr));
-  EXPECT_EQ(nullptr, manager.FindComponent("comp1.comp2[1e1]", nullptr));
-  EXPECT_EQ(nullptr, manager.FindComponent("comp1.comp2[1", nullptr));
+  EXPECT_EQ(nullptr, manager_.FindComponent("comp1.comp2[s]", nullptr));
+  EXPECT_EQ(nullptr, manager_.FindComponent("comp1.comp2[-2]", nullptr));
+  EXPECT_EQ(nullptr, manager_.FindComponent("comp1.comp2[1e1]", nullptr));
+  EXPECT_EQ(nullptr, manager_.FindComponent("comp1.comp2[1", nullptr));
 }
 
-TEST(ComponentManager, ParseCommandInstance) {
-  ComponentManagerImpl manager;
+TEST_F(ComponentManagerTest, ParseCommandInstance) {
   const char kTraits[] = R"({
     "trait1": {
       "commands": {
@@ -644,9 +622,9 @@
     }
   })";
   auto traits = CreateDictionaryValue(kTraits);
-  ASSERT_TRUE(manager.LoadTraits(*traits, nullptr));
-  ASSERT_TRUE(manager.AddComponent("", "comp1", {"trait1"}, nullptr));
-  ASSERT_TRUE(manager.AddComponent("", "comp2", {"trait2"}, nullptr));
+  ASSERT_TRUE(manager_.LoadTraits(*traits, nullptr));
+  ASSERT_TRUE(manager_.AddComponent("", "comp1", {"trait1"}, nullptr));
+  ASSERT_TRUE(manager_.AddComponent("", "comp2", {"trait2"}, nullptr));
 
   std::string id;
   const char kCommand1[] = R"({
@@ -657,13 +635,15 @@
   })";
   auto command1 = CreateDictionaryValue(kCommand1);
   EXPECT_NE(nullptr,
-            manager.ParseCommandInstance(*command1, Command::Origin::kLocal,
-                                         UserRole::kUser, &id, nullptr).get());
+            manager_.ParseCommandInstance(*command1, Command::Origin::kLocal,
+                                          UserRole::kUser, &id, nullptr)
+                .get());
   EXPECT_EQ("1234-12345", id);
   // Not enough access rights
   EXPECT_EQ(nullptr,
-            manager.ParseCommandInstance(*command1, Command::Origin::kLocal,
-                                         UserRole::kViewer, &id, nullptr).get());
+            manager_.ParseCommandInstance(*command1, Command::Origin::kLocal,
+                                          UserRole::kViewer, &id, nullptr)
+                .get());
 
   const char kCommand2[] = R"({
     "name": "trait1.command3",
@@ -673,8 +653,9 @@
   auto command2 = CreateDictionaryValue(kCommand2);
   // trait1.command3 doesn't exist
   EXPECT_EQ(nullptr,
-            manager.ParseCommandInstance(*command2, Command::Origin::kLocal,
-                                         UserRole::kOwner, &id, nullptr).get());
+            manager_.ParseCommandInstance(*command2, Command::Origin::kLocal,
+                                          UserRole::kOwner, &id, nullptr)
+                .get());
   EXPECT_TRUE(id.empty());
 
   const char kCommand3[] = R"({
@@ -685,8 +666,9 @@
   auto command3 = CreateDictionaryValue(kCommand3);
   // Component comp1 doesn't have trait2.
   EXPECT_EQ(nullptr,
-            manager.ParseCommandInstance(*command3, Command::Origin::kLocal,
-                                         UserRole::kOwner, &id, nullptr).get());
+            manager_.ParseCommandInstance(*command3, Command::Origin::kLocal,
+                                          UserRole::kOwner, &id, nullptr)
+                .get());
 
   // No component specified, find the suitable component
   const char kCommand4[] = R"({
@@ -694,7 +676,7 @@
     "parameters": {}
   })";
   auto command4 = CreateDictionaryValue(kCommand4);
-  auto command_instance = manager.ParseCommandInstance(
+  auto command_instance = manager_.ParseCommandInstance(
       *command4, Command::Origin::kLocal, UserRole::kOwner, &id, nullptr);
   EXPECT_NE(nullptr, command_instance.get());
   EXPECT_EQ("comp1", command_instance->GetComponent());
@@ -704,7 +686,7 @@
     "parameters": {}
   })";
   auto command5 = CreateDictionaryValue(kCommand5);
-  command_instance = manager.ParseCommandInstance(
+  command_instance = manager_.ParseCommandInstance(
       *command5, Command::Origin::kLocal, UserRole::kOwner, &id, nullptr);
   EXPECT_NE(nullptr, command_instance.get());
   EXPECT_EQ("comp2", command_instance->GetComponent());
@@ -716,12 +698,12 @@
   })";
   auto command6 = CreateDictionaryValue(kCommand6);
   EXPECT_EQ(nullptr,
-            manager.ParseCommandInstance(*command6, Command::Origin::kLocal,
-                                         UserRole::kOwner, &id, nullptr).get());
+            manager_.ParseCommandInstance(*command6, Command::Origin::kLocal,
+                                          UserRole::kOwner, &id, nullptr)
+                .get());
 }
 
-TEST(ComponentManager, AddCommand) {
-  ComponentManagerImpl manager;
+TEST_F(ComponentManagerTest, AddCommand) {
   const char kTraits[] = R"({
     "trait1": {
       "commands": {
@@ -730,8 +712,8 @@
     }
   })";
   auto traits = CreateDictionaryValue(kTraits);
-  ASSERT_TRUE(manager.LoadTraits(*traits, nullptr));
-  ASSERT_TRUE(manager.AddComponent("", "comp1", {"trait1"}, nullptr));
+  ASSERT_TRUE(manager_.LoadTraits(*traits, nullptr));
+  ASSERT_TRUE(manager_.AddComponent("", "comp1", {"trait1"}, nullptr));
 
   std::string id;
   const char kCommand[] = R"({
@@ -741,17 +723,16 @@
     "parameters": {}
   })";
   auto command = CreateDictionaryValue(kCommand);
-  auto command_instance = manager.ParseCommandInstance(
+  auto command_instance = manager_.ParseCommandInstance(
       *command, Command::Origin::kLocal, UserRole::kUser, &id, nullptr);
   ASSERT_NE(nullptr, command_instance.get());
-  manager.AddCommand(std::move(command_instance));
-  const auto* queued_command = manager.FindCommand(id);
+  manager_.AddCommand(std::move(command_instance));
+  const auto* queued_command = manager_.FindCommand(id);
   ASSERT_NE(nullptr, queued_command);
   EXPECT_EQ("trait1.command1", queued_command->GetName());
 }
 
-TEST(ComponentManager, AddCommandHandler) {
-  ComponentManagerImpl manager;
+TEST_F(ComponentManagerTest, AddCommandHandler) {
   const char kTraits[] = R"({
     "trait1": {
       "commands": {
@@ -765,9 +746,10 @@
     }
   })";
   auto traits = CreateDictionaryValue(kTraits);
-  ASSERT_TRUE(manager.LoadTraits(*traits, nullptr));
-  ASSERT_TRUE(manager.AddComponent("", "comp1", {"trait1"}, nullptr));
-  ASSERT_TRUE(manager.AddComponent("", "comp2", {"trait1", "trait2"}, nullptr));
+  ASSERT_TRUE(manager_.LoadTraits(*traits, nullptr));
+  ASSERT_TRUE(manager_.AddComponent("", "comp1", {"trait1"}, nullptr));
+  ASSERT_TRUE(
+      manager_.AddComponent("", "comp2", {"trait1", "trait2"}, nullptr));
 
   std::string last_tags;
   auto handler = [&last_tags](int tag, const std::weak_ptr<Command>& command) {
@@ -776,9 +758,12 @@
     last_tags += std::to_string(tag);
   };
 
-  manager.AddCommandHandler("comp1", "trait1.command1", base::Bind(handler, 1));
-  manager.AddCommandHandler("comp2", "trait1.command1", base::Bind(handler, 2));
-  manager.AddCommandHandler("comp2", "trait2.command2", base::Bind(handler, 3));
+  manager_.AddCommandHandler("comp1", "trait1.command1",
+                             base::Bind(handler, 1));
+  manager_.AddCommandHandler("comp2", "trait1.command1",
+                             base::Bind(handler, 2));
+  manager_.AddCommandHandler("comp2", "trait2.command2",
+                             base::Bind(handler, 3));
   EXPECT_TRUE(last_tags.empty());
 
   const char kCommand1[] = R"({
@@ -786,10 +771,10 @@
     "component": "comp1"
   })";
   auto command1 = CreateDictionaryValue(kCommand1);
-  auto command_instance = manager.ParseCommandInstance(
+  auto command_instance = manager_.ParseCommandInstance(
       *command1, Command::Origin::kCloud, UserRole::kUser, nullptr, nullptr);
   ASSERT_NE(nullptr, command_instance.get());
-  manager.AddCommand(std::move(command_instance));
+  manager_.AddCommand(std::move(command_instance));
   EXPECT_EQ("1", last_tags);
   last_tags.clear();
 
@@ -798,10 +783,10 @@
     "component": "comp2"
   })";
   auto command2 = CreateDictionaryValue(kCommand2);
-  command_instance = manager.ParseCommandInstance(
+  command_instance = manager_.ParseCommandInstance(
       *command2, Command::Origin::kCloud, UserRole::kUser, nullptr, nullptr);
   ASSERT_NE(nullptr, command_instance.get());
-  manager.AddCommand(std::move(command_instance));
+  manager_.AddCommand(std::move(command_instance));
   EXPECT_EQ("2", last_tags);
   last_tags.clear();
 
@@ -811,16 +796,15 @@
     "parameters": {}
   })";
   auto command3 = CreateDictionaryValue(kCommand3);
-  command_instance = manager.ParseCommandInstance(
+  command_instance = manager_.ParseCommandInstance(
       *command3, Command::Origin::kCloud, UserRole::kUser, nullptr, nullptr);
   ASSERT_NE(nullptr, command_instance.get());
-  manager.AddCommand(std::move(command_instance));
+  manager_.AddCommand(std::move(command_instance));
   EXPECT_EQ("3", last_tags);
   last_tags.clear();
 }
 
-TEST(ComponentManager, AddDefaultCommandHandler) {
-  ComponentManagerImpl manager;
+TEST_F(ComponentManagerTest, AddDefaultCommandHandler) {
   const char kTraits[] = R"({
     "trait1": {
       "commands": {
@@ -834,15 +818,15 @@
     }
   })";
   auto traits = CreateDictionaryValue(kTraits);
-  ASSERT_TRUE(manager.LoadTraits(*traits, nullptr));
-  ASSERT_TRUE(manager.AddComponent("", "comp", {"trait1", "trait2"}, nullptr));
+  ASSERT_TRUE(manager_.LoadTraits(*traits, nullptr));
+  ASSERT_TRUE(manager_.AddComponent("", "comp", {"trait1", "trait2"}, nullptr));
 
   int count = 0;
   auto handler = [&count](int tag, const std::weak_ptr<Command>& command) {
     count++;
   };
 
-  manager.AddCommandHandler("", "", base::Bind(handler, 1));
+  manager_.AddCommandHandler("", "", base::Bind(handler, 1));
   EXPECT_EQ(0, count);
 
   const char kCommand1[] = R"({
@@ -850,10 +834,10 @@
     "component": "comp"
   })";
   auto command1 = CreateDictionaryValue(kCommand1);
-  auto command_instance = manager.ParseCommandInstance(
+  auto command_instance = manager_.ParseCommandInstance(
       *command1, Command::Origin::kCloud, UserRole::kUser, nullptr, nullptr);
   ASSERT_NE(nullptr, command_instance.get());
-  manager.AddCommand(std::move(command_instance));
+  manager_.AddCommand(std::move(command_instance));
   EXPECT_EQ(1, count);
 
   const char kCommand2[] = R"({
@@ -861,20 +845,19 @@
     "component": "comp"
   })";
   auto command2 = CreateDictionaryValue(kCommand2);
-  command_instance = manager.ParseCommandInstance(
+  command_instance = manager_.ParseCommandInstance(
       *command2, Command::Origin::kCloud, UserRole::kUser, nullptr, nullptr);
   ASSERT_NE(nullptr, command_instance.get());
-  manager.AddCommand(std::move(command_instance));
+  manager_.AddCommand(std::move(command_instance));
   EXPECT_EQ(2, count);
 }
 
-TEST(ComponentManager, SetStateProperties) {
-  ComponentManagerImpl manager;
-  CreateTestComponentTree(&manager);
+TEST_F(ComponentManagerTest, SetStateProperties) {
+  CreateTestComponentTree(&manager_);
 
   const char kState1[] = R"({"t1": {"p1": 0, "p2": "foo"}})";
   auto state1 = CreateDictionaryValue(kState1);
-  ASSERT_TRUE(manager.SetStateProperties("comp1", *state1, nullptr));
+  ASSERT_TRUE(manager_.SetStateProperties("comp1", *state1, nullptr));
   const char kExpected1[] = R"({
     "comp1": {
       "traits": [ "t1" ],
@@ -901,11 +884,11 @@
       }
     }
   })";
-  EXPECT_JSON_EQ(kExpected1, manager.GetComponents());
+  EXPECT_JSON_EQ(kExpected1, manager_.GetComponents());
 
   const char kState2[] = R"({"t1": {"p1": {"bar": "baz"}}})";
   auto state2 = CreateDictionaryValue(kState2);
-  ASSERT_TRUE(manager.SetStateProperties("comp1", *state2, nullptr));
+  ASSERT_TRUE(manager_.SetStateProperties("comp1", *state2, nullptr));
 
   const char kExpected2[] = R"({
     "comp1": {
@@ -933,12 +916,12 @@
       }
     }
   })";
-  EXPECT_JSON_EQ(kExpected2, manager.GetComponents());
+  EXPECT_JSON_EQ(kExpected2, manager_.GetComponents());
 
   const char kState3[] = R"({"t5": {"p1": 1}})";
   auto state3 = CreateDictionaryValue(kState3);
-  ASSERT_TRUE(manager.SetStateProperties("comp1.comp2[1].comp3.comp4", *state3,
-                                         nullptr));
+  ASSERT_TRUE(manager_.SetStateProperties("comp1.comp2[1].comp3.comp4", *state3,
+                                          nullptr));
 
   const char kExpected3[] = R"({
     "comp1": {
@@ -967,14 +950,13 @@
       }
     }
   })";
-  EXPECT_JSON_EQ(kExpected3, manager.GetComponents());
+  EXPECT_JSON_EQ(kExpected3, manager_.GetComponents());
 }
 
-TEST(ComponentManager, SetStatePropertiesFromJson) {
-  ComponentManagerImpl manager;
-  CreateTestComponentTree(&manager);
+TEST_F(ComponentManagerTest, SetStatePropertiesFromJson) {
+  CreateTestComponentTree(&manager_);
 
-  ASSERT_TRUE(manager.SetStatePropertiesFromJson(
+  ASSERT_TRUE(manager_.SetStatePropertiesFromJson(
       "comp1.comp2[1].comp3.comp4", R"({"t5": {"p1": 3}, "t6": {"p2": 5}})",
       nullptr));
 
@@ -1007,11 +989,10 @@
       }
     }
   })";
-  EXPECT_JSON_EQ(kExpected, manager.GetComponents());
+  EXPECT_JSON_EQ(kExpected, manager_.GetComponents());
 }
 
-TEST(ComponentManager, SetGetStateProperty) {
-  ComponentManagerImpl manager;
+TEST_F(ComponentManagerTest, SetGetStateProperty) {
   const char kTraits[] = R"({
     "trait1": {
       "state": {
@@ -1027,11 +1008,12 @@
     }
   })";
   auto traits = CreateDictionaryValue(kTraits);
-  ASSERT_TRUE(manager.LoadTraits(*traits, nullptr));
-  ASSERT_TRUE(manager.AddComponent("", "comp1", {"trait1", "trait2"}, nullptr));
+  ASSERT_TRUE(manager_.LoadTraits(*traits, nullptr));
+  ASSERT_TRUE(
+      manager_.AddComponent("", "comp1", {"trait1", "trait2"}, nullptr));
 
   base::StringValue p1("foo");
-  ASSERT_TRUE(manager.SetStateProperty("comp1", "trait1.prop1", p1, nullptr));
+  ASSERT_TRUE(manager_.SetStateProperty("comp1", "trait1.prop1", p1, nullptr));
 
   const char kExpected1[] = R"({
     "comp1": {
@@ -1041,10 +1023,10 @@
       }
     }
   })";
-  EXPECT_JSON_EQ(kExpected1, manager.GetComponents());
+  EXPECT_JSON_EQ(kExpected1, manager_.GetComponents());
 
   base::FundamentalValue p2(2);
-  ASSERT_TRUE(manager.SetStateProperty("comp1", "trait2.prop3", p2, nullptr));
+  ASSERT_TRUE(manager_.SetStateProperty("comp1", "trait2.prop3", p2, nullptr));
 
   const char kExpected2[] = R"({
     "comp1": {
@@ -1055,29 +1037,27 @@
       }
     }
   })";
-  EXPECT_JSON_EQ(kExpected2, manager.GetComponents());
+  EXPECT_JSON_EQ(kExpected2, manager_.GetComponents());
   // Just the package name without property:
-  EXPECT_FALSE(manager.SetStateProperty("comp1", "trait2", p2, nullptr));
+  EXPECT_FALSE(manager_.SetStateProperty("comp1", "trait2", p2, nullptr));
 
-  const base::Value* value = manager.GetStateProperty("comp1", "trait1.prop1",
-                                                      nullptr);
+  const base::Value* value =
+      manager_.GetStateProperty("comp1", "trait1.prop1", nullptr);
   ASSERT_NE(nullptr, value);
   EXPECT_TRUE(p1.Equals(value));
-  value = manager.GetStateProperty("comp1", "trait2.prop3", nullptr);
+  value = manager_.GetStateProperty("comp1", "trait2.prop3", nullptr);
   ASSERT_NE(nullptr, value);
   EXPECT_TRUE(p2.Equals(value));
 
   // Non-existing property:
-  EXPECT_EQ(nullptr, manager.GetStateProperty("comp1", "trait2.p", nullptr));
+  EXPECT_EQ(nullptr, manager_.GetStateProperty("comp1", "trait2.p", nullptr));
   // Non-existing component
-  EXPECT_EQ(nullptr, manager.GetStateProperty("comp2", "trait.prop", nullptr));
+  EXPECT_EQ(nullptr, manager_.GetStateProperty("comp2", "trait.prop", nullptr));
   // Just the package name without property:
-  EXPECT_EQ(nullptr, manager.GetStateProperty("comp1", "trait2", nullptr));
+  EXPECT_EQ(nullptr, manager_.GetStateProperty("comp1", "trait2", nullptr));
 }
 
-TEST(ComponentManager, AddStateChangedCallback) {
-  SimpleTestClock clock;
-  ComponentManagerImpl manager{&clock};
+TEST_F(ComponentManagerTest, AddStateChangedCallback) {
   const char kTraits[] = R"({
     "trait1": {
       "state": {
@@ -1087,38 +1067,36 @@
     }
   })";
   auto traits = CreateDictionaryValue(kTraits);
-  ASSERT_TRUE(manager.LoadTraits(*traits, nullptr));
-  ASSERT_TRUE(manager.AddComponent("", "comp1", {"trait1"}, nullptr));
+  ASSERT_TRUE(manager_.LoadTraits(*traits, nullptr));
+  ASSERT_TRUE(manager_.AddComponent("", "comp1", {"trait1"}, nullptr));
 
   int count = 0;
   int count2 = 0;
-  manager.AddStateChangedCallback(base::Bind([&count]() { count++; }));
-  manager.AddStateChangedCallback(base::Bind([&count2]() { count2++; }));
+  manager_.AddStateChangedCallback(base::Bind([&count]() { count++; }));
+  manager_.AddStateChangedCallback(base::Bind([&count2]() { count2++; }));
   EXPECT_EQ(1, count);
   EXPECT_EQ(1, count2);
-  EXPECT_EQ(0, manager.GetLastStateChangeId());
+  EXPECT_EQ(0, manager_.GetLastStateChangeId());
 
   base::StringValue p1("foo");
-  ASSERT_TRUE(manager.SetStateProperty("comp1", "trait1.prop1", p1, nullptr));
+  ASSERT_TRUE(manager_.SetStateProperty("comp1", "trait1.prop1", p1, nullptr));
   EXPECT_EQ(2, count);
   EXPECT_EQ(2, count2);
-  EXPECT_EQ(1, manager.GetLastStateChangeId());
+  EXPECT_EQ(1, manager_.GetLastStateChangeId());
 
-  ASSERT_TRUE(manager.SetStateProperty("comp1", "trait1.prop2", p1, nullptr));
+  ASSERT_TRUE(manager_.SetStateProperty("comp1", "trait1.prop2", p1, nullptr));
   EXPECT_EQ(3, count);
   EXPECT_EQ(3, count2);
-  EXPECT_EQ(2, manager.GetLastStateChangeId());
+  EXPECT_EQ(2, manager_.GetLastStateChangeId());
 
   // Fail - no component.
-  ASSERT_FALSE(manager.SetStateProperty("comp2", "trait1.prop2", p1, nullptr));
+  ASSERT_FALSE(manager_.SetStateProperty("comp2", "trait1.prop2", p1, nullptr));
   EXPECT_EQ(3, count);
   EXPECT_EQ(3, count2);
-  EXPECT_EQ(2, manager.GetLastStateChangeId());
+  EXPECT_EQ(2, manager_.GetLastStateChangeId());
 }
 
-TEST(ComponentManager, ComponentStateUpdates) {
-  SimpleTestClock clock;
-  ComponentManagerImpl manager{&clock};
+TEST_F(ComponentManagerTest, ComponentStateUpdates) {
   const char kTraits[] = R"({
     "trait1": {
       "state": {
@@ -1134,48 +1112,50 @@
     }
   })";
   auto traits = CreateDictionaryValue(kTraits);
-  ASSERT_TRUE(manager.LoadTraits(*traits, nullptr));
-  ASSERT_TRUE(manager.AddComponent("", "comp1", {"trait1", "trait2"}, nullptr));
-  ASSERT_TRUE(manager.AddComponent("", "comp2", {"trait1", "trait2"}, nullptr));
+  ASSERT_TRUE(manager_.LoadTraits(*traits, nullptr));
+  ASSERT_TRUE(
+      manager_.AddComponent("", "comp1", {"trait1", "trait2"}, nullptr));
+  ASSERT_TRUE(
+      manager_.AddComponent("", "comp2", {"trait1", "trait2"}, nullptr));
 
   std::vector<ComponentManager::UpdateID> updates1;
   auto callback1 = [&updates1](ComponentManager::UpdateID id) {
     updates1.push_back(id);
   };
   // State change queue is empty, callback should be called immediately.
-  auto token1 = manager.AddServerStateUpdatedCallback(base::Bind(callback1));
+  auto token1 = manager_.AddServerStateUpdatedCallback(base::Bind(callback1));
   ASSERT_EQ(1u, updates1.size());
-  EXPECT_EQ(manager.GetLastStateChangeId(), updates1.front());
+  EXPECT_EQ(manager_.GetLastStateChangeId(), updates1.front());
   updates1.clear();
 
   base::StringValue foo("foo");
   base::Time time1 = base::Time::Now();
-  clock.SetNow(time1);
+  EXPECT_CALL(clock_, Now()).WillRepeatedly(Return(time1));
   // These three updates should be grouped into two separate state change queue
   // items, since they all happen at the same time, but for two different
   // components.
-  ASSERT_TRUE(manager.SetStateProperty("comp1", "trait1.prop1", foo, nullptr));
-  ASSERT_TRUE(manager.SetStateProperty("comp2", "trait2.prop3", foo, nullptr));
-  ASSERT_TRUE(manager.SetStateProperty("comp1", "trait1.prop2", foo, nullptr));
+  ASSERT_TRUE(manager_.SetStateProperty("comp1", "trait1.prop1", foo, nullptr));
+  ASSERT_TRUE(manager_.SetStateProperty("comp2", "trait2.prop3", foo, nullptr));
+  ASSERT_TRUE(manager_.SetStateProperty("comp1", "trait1.prop2", foo, nullptr));
 
   std::vector<ComponentManager::UpdateID> updates2;
   auto callback2 = [&updates2](ComponentManager::UpdateID id) {
     updates2.push_back(id);
   };
   // State change queue is not empty, so callback will be called later.
-  auto token2 = manager.AddServerStateUpdatedCallback(base::Bind(callback2));
+  auto token2 = manager_.AddServerStateUpdatedCallback(base::Bind(callback2));
   EXPECT_TRUE(updates2.empty());
 
   base::StringValue bar("bar");
   base::Time time2 = time1 + base::TimeDelta::FromSeconds(1);
-  clock.SetNow(time2);
+  EXPECT_CALL(clock_, Now()).WillRepeatedly(Return(time2));
   // Two more update events (as above) but at |time2|.
-  ASSERT_TRUE(manager.SetStateProperty("comp1", "trait1.prop1", bar, nullptr));
-  ASSERT_TRUE(manager.SetStateProperty("comp2", "trait2.prop3", bar, nullptr));
-  ASSERT_TRUE(manager.SetStateProperty("comp1", "trait1.prop2", bar, nullptr));
+  ASSERT_TRUE(manager_.SetStateProperty("comp1", "trait1.prop1", bar, nullptr));
+  ASSERT_TRUE(manager_.SetStateProperty("comp2", "trait2.prop3", bar, nullptr));
+  ASSERT_TRUE(manager_.SetStateProperty("comp1", "trait1.prop2", bar, nullptr));
 
-  auto snapshot = manager.GetAndClearRecordedStateChanges();
-  EXPECT_EQ(manager.GetLastStateChangeId(), snapshot.update_id);
+  auto snapshot = manager_.GetAndClearRecordedStateChanges();
+  EXPECT_EQ(manager_.GetLastStateChangeId(), snapshot.update_id);
   ASSERT_EQ(4u, snapshot.state_changes.size());
 
   EXPECT_EQ("comp1", snapshot.state_changes[0].component);
@@ -1199,38 +1179,37 @@
                  *snapshot.state_changes[3].changed_properties);
 
   // Make sure previous GetAndClearRecordedStateChanges() clears the queue.
-  auto snapshot2 = manager.GetAndClearRecordedStateChanges();
-  EXPECT_EQ(manager.GetLastStateChangeId(), snapshot2.update_id);
+  auto snapshot2 = manager_.GetAndClearRecordedStateChanges();
+  EXPECT_EQ(manager_.GetLastStateChangeId(), snapshot2.update_id);
   EXPECT_TRUE(snapshot2.state_changes.empty());
 
   // Now indicate that we have update the changes on the server.
-  manager.NotifyStateUpdatedOnServer(snapshot.update_id);
+  manager_.NotifyStateUpdatedOnServer(snapshot.update_id);
   ASSERT_EQ(1u, updates1.size());
   EXPECT_EQ(snapshot.update_id, updates1.front());
   ASSERT_EQ(1u, updates2.size());
   EXPECT_EQ(snapshot.update_id, updates2.front());
 }
 
-TEST(ComponentManager, FindComponentWithTrait) {
-  ComponentManagerImpl manager;
+TEST_F(ComponentManagerTest, FindComponentWithTrait) {
   const char kTraits[] = R"({
     "trait1": {},
     "trait2": {},
     "trait3": {}
   })";
   auto traits = CreateDictionaryValue(kTraits);
-  ASSERT_TRUE(manager.LoadTraits(*traits, nullptr));
-  ASSERT_TRUE(manager.AddComponent("", "comp1", {"trait1", "trait2"}, nullptr));
-  ASSERT_TRUE(manager.AddComponent("", "comp2", {"trait3"}, nullptr));
+  ASSERT_TRUE(manager_.LoadTraits(*traits, nullptr));
+  ASSERT_TRUE(
+      manager_.AddComponent("", "comp1", {"trait1", "trait2"}, nullptr));
+  ASSERT_TRUE(manager_.AddComponent("", "comp2", {"trait3"}, nullptr));
 
-  EXPECT_EQ("comp1", manager.FindComponentWithTrait("trait1"));
-  EXPECT_EQ("comp1", manager.FindComponentWithTrait("trait2"));
-  EXPECT_EQ("comp2", manager.FindComponentWithTrait("trait3"));
-  EXPECT_EQ("", manager.FindComponentWithTrait("trait4"));
+  EXPECT_EQ("comp1", manager_.FindComponentWithTrait("trait1"));
+  EXPECT_EQ("comp1", manager_.FindComponentWithTrait("trait2"));
+  EXPECT_EQ("comp2", manager_.FindComponentWithTrait("trait3"));
+  EXPECT_EQ("", manager_.FindComponentWithTrait("trait4"));
 }
 
-TEST(ComponentManager, AddLegacyCommandAndStateDefinitions) {
-  ComponentManagerImpl manager;
+TEST_F(ComponentManagerTest, AddLegacyCommandAndStateDefinitions) {
   const char kCommandDefs1[] = R"({
     "package1": {
       "command1": {
@@ -1248,7 +1227,7 @@
     }
   })";
   auto json = CreateDictionaryValue(kCommandDefs1);
-  EXPECT_TRUE(manager.AddLegacyCommandDefinitions(*json, nullptr));
+  EXPECT_TRUE(manager_.AddLegacyCommandDefinitions(*json, nullptr));
   const char kExpected1[] = R"({
     "package1": {
       "commands": {
@@ -1269,11 +1248,11 @@
       }
     }
   })";
-  EXPECT_JSON_EQ(kExpected1, manager.GetTraits());
+  EXPECT_JSON_EQ(kExpected1, manager_.GetTraits());
   const char kExpectedComponents1[] = R"({
     "__weave__": { "traits": ["package1", "package2"] }
   })";
-  EXPECT_JSON_EQ(kExpectedComponents1, manager.GetComponents());
+  EXPECT_JSON_EQ(kExpectedComponents1, manager_.GetComponents());
 
   const char kCommandDefs2[] = R"({
     "package2": {
@@ -1285,7 +1264,7 @@
     }
   })";
   json = CreateDictionaryValue(kCommandDefs2);
-  EXPECT_TRUE(manager.AddLegacyCommandDefinitions(*json, nullptr));
+  EXPECT_TRUE(manager_.AddLegacyCommandDefinitions(*json, nullptr));
   const char kExpected2[] = R"({
     "package1": {
       "commands": {
@@ -1313,14 +1292,14 @@
       }
     }
   })";
-  EXPECT_JSON_EQ(kExpected2, manager.GetTraits());
+  EXPECT_JSON_EQ(kExpected2, manager_.GetTraits());
   const char kExpectedComponents2[] = R"({
     "__weave__": { "traits": ["package1", "package2", "package3"] }
   })";
-  EXPECT_JSON_EQ(kExpectedComponents2, manager.GetComponents());
+  EXPECT_JSON_EQ(kExpectedComponents2, manager_.GetComponents());
 
   // Redefining existing commands.
-  EXPECT_FALSE(manager.AddLegacyCommandDefinitions(*json, nullptr));
+  EXPECT_FALSE(manager_.AddLegacyCommandDefinitions(*json, nullptr));
 
   const char kStateDefs1[] = R"({
     "package1": {
@@ -1333,11 +1312,11 @@
     }
   })";
   json = CreateDictionaryValue(kStateDefs1);
-  EXPECT_TRUE(manager.AddLegacyStateDefinitions(*json, nullptr));
+  EXPECT_TRUE(manager_.AddLegacyStateDefinitions(*json, nullptr));
   const char kExpectedComponents3[] = R"({
     "__weave__": { "traits": ["package1", "package2", "package3", "package4"] }
   })";
-  EXPECT_JSON_EQ(kExpectedComponents3, manager.GetComponents());
+  EXPECT_JSON_EQ(kExpectedComponents3, manager_.GetComponents());
 
   const char kExpected3[] = R"({
     "package1": {
@@ -1376,14 +1355,14 @@
       }
     }
   })";
-  EXPECT_JSON_EQ(kExpected3, manager.GetTraits());
+  EXPECT_JSON_EQ(kExpected3, manager_.GetTraits());
   const char kExpectedComponents4[] = R"({
     "__weave__": { "traits": ["package1", "package2", "package3", "package4"] }
   })";
-  EXPECT_JSON_EQ(kExpectedComponents4, manager.GetComponents());
+  EXPECT_JSON_EQ(kExpectedComponents4, manager_.GetComponents());
 
   // Redefining existing commands.
-  EXPECT_FALSE(manager.AddLegacyStateDefinitions(*json, nullptr));
+  EXPECT_FALSE(manager_.AddLegacyStateDefinitions(*json, nullptr));
 
   const char kExpected4[] = R"({
     "package1": {
@@ -1406,11 +1385,10 @@
       "command2": { "minimalRole": "owner" }
     }
   })";
-  EXPECT_JSON_EQ(kExpected4, manager.GetLegacyCommandDefinitions());
+  EXPECT_JSON_EQ(kExpected4, manager_.GetLegacyCommandDefinitions());
 }
 
-TEST(ComponentManager, GetLegacyState) {
-  ComponentManagerImpl manager;
+TEST_F(ComponentManagerTest, GetLegacyState) {
   const char kTraits[] = R"({
     "trait1": {
       "state": {
@@ -1426,13 +1404,13 @@
     }
   })";
   auto traits = CreateDictionaryValue(kTraits);
-  ASSERT_TRUE(manager.LoadTraits(*traits, nullptr));
-  ASSERT_TRUE(manager.AddComponent("", "comp1", {"trait1"}, nullptr));
-  ASSERT_TRUE(manager.AddComponent("", "comp2", {"trait2"}, nullptr));
+  ASSERT_TRUE(manager_.LoadTraits(*traits, nullptr));
+  ASSERT_TRUE(manager_.AddComponent("", "comp1", {"trait1"}, nullptr));
+  ASSERT_TRUE(manager_.AddComponent("", "comp2", {"trait2"}, nullptr));
 
-  ASSERT_TRUE(manager.SetStatePropertiesFromJson(
+  ASSERT_TRUE(manager_.SetStatePropertiesFromJson(
       "comp1", R"({"trait1": {"prop1": "foo", "prop2": "bar"}})", nullptr));
-  ASSERT_TRUE(manager.SetStatePropertiesFromJson(
+  ASSERT_TRUE(manager_.SetStatePropertiesFromJson(
       "comp2", R"({"trait2": {"prop3": "baz", "prop4": "quux"}})", nullptr));
 
   const char kExpected[] = R"({
@@ -1445,10 +1423,10 @@
       "prop4": "quux"
     }
   })";
-  EXPECT_JSON_EQ(kExpected, manager.GetLegacyState());
+  EXPECT_JSON_EQ(kExpected, manager_.GetLegacyState());
 }
 
-TEST(ComponentManager, TestMockComponentManager) {
+TEST_F(ComponentManagerTest, TestMockComponentManager) {
   // Check that all the virtual methods are mocked out.
   MockComponentManager mock;
 }
diff --git a/src/test/mock_clock.h b/src/test/mock_clock.h
new file mode 100644
index 0000000..f1a2260
--- /dev/null
+++ b/src/test/mock_clock.h
@@ -0,0 +1,22 @@
+// Copyright 2015 The Weave Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef LIBWEAVE_SRC_TEST_MOCK_CLOCK_H_
+#define LIBWEAVE_SRC_TEST_MOCK_CLOCK_H_
+
+#include <base/time/clock.h>
+#include <gmock/gmock.h>
+
+namespace weave {
+namespace test {
+
+class MockClock : public base::Clock {
+ public:
+  MOCK_METHOD0(Now, base::Time());
+};
+
+}  // namespace test
+}  // namespace weave
+
+#endif  // LIBWEAVE_SRC_TEST_MOCK_CLOCK_H_