Rename *BlackList* into *Revocation*

This name matches better new trait and semantic.

BUG: 27313743
Change-Id: I0cbc7b40cf14b17cfbffb7f58572a7ea6d81c542
Reviewed-on: https://weave-review.googlesource.com/2730
Reviewed-by: Alex Vakulenko <avakulenko@google.com>

13 files changed, 95 insertions, 93 deletions

diff --git a/src/access_api_handler.cc b/src/access_api_handler.cc
index ec22094..dcfae45 100644
--- a/src/access_api_handler.cc
+++ b/src/access_api_handler.cc
@@ -7,7 +7,7 @@
 #include <base/bind.h>
 #include <weave/device.h>
 
-#include "src/access_black_list_manager.h"
+#include "src/access_revocation_manager.h"
 #include "src/commands/schema_constants.h"
 #include "src/data_encoding.h"
 #include "src/json_error_codes.h"
@@ -24,7 +24,7 @@ const char kUserId[] = "userId";
 const char kApplicationId[] = "applicationId";
 const char kExpirationTime[] = "expirationTime";
 const char kRevocationTimestamp[] = "revocationTimestamp";
-const char kBlackList[] = "revocationListEntries";
+const char kRevocationList[] = "revocationListEntries";
 
 bool GetIds(const base::DictionaryValue& parameters,
             std::vector<uint8_t>* user_id_decoded,
@@ -52,7 +52,7 @@ bool GetIds(const base::DictionaryValue& parameters,
 }  // namespace
 
 AccessApiHandler::AccessApiHandler(Device* device,
-                                   AccessBlackListManager* manager)
+                                   AccessRevocationManager* manager)
     : device_{device}, manager_{manager} {
   device_->AddTraitDefinitionsFromJson(R"({
     "_accessRevocationList": {
@@ -155,9 +155,9 @@ void AccessApiHandler::Block(const std::weak_ptr<Command>& cmd) {
     return;
   }
 
-  manager_->Block(AccessBlackListManager::Entry{user_id, app_id,
-                                                FromJ2000Time(revocation_j2k),
-                                                FromJ2000Time(expiration_j2k)},
+  manager_->Block(AccessRevocationManager::Entry{user_id, app_id,
+                                                 FromJ2000Time(revocation_j2k),
+                                                 FromJ2000Time(expiration_j2k)},
                   base::Bind(&AccessApiHandler::OnCommandDone,
                              weak_ptr_factory_.GetWeakPtr(), cmd));
 }
@@ -180,7 +180,7 @@ void AccessApiHandler::List(const std::weak_ptr<Command>& cmd) {
   }
 
   base::DictionaryValue result;
-  result.Set(kBlackList, entries.release());
+  result.Set(kRevocationList, entries.release());
 
   command->Complete(result, nullptr);
 }
diff --git a/src/access_api_handler.h b/src/access_api_handler.h
index 19fe799..16eaa6f 100644
--- a/src/access_api_handler.h
+++ b/src/access_api_handler.h
@@ -12,19 +12,19 @@
 
 namespace weave {
 
-class AccessBlackListManager;
+class AccessRevocationManager;
 class Command;
 class Device;
 
-// Handles commands for 'accessControlBlackList' trait.
+// Handles commands for '_accessRevocationList' trait.
 // Objects of the class subscribe for notification from CommandManager and
 // execute incoming commands.
 // Handled commands:
-//  accessControlBlackList.revoke
-//  accessControlBlackList.list
+//  _accessRevocationList.revoke
+//  _accessRevocationList.list
 class AccessApiHandler final {
  public:
-  AccessApiHandler(Device* device, AccessBlackListManager* manager);
+  AccessApiHandler(Device* device, AccessRevocationManager* manager);
 
  private:
   void Block(const std::weak_ptr<Command>& command);
@@ -34,7 +34,7 @@ class AccessApiHandler final {
   void OnCommandDone(const std::weak_ptr<Command>& command, ErrorPtr error);
 
   Device* device_{nullptr};
-  AccessBlackListManager* manager_{nullptr};
+  AccessRevocationManager* manager_{nullptr};
 
   base::WeakPtrFactory<AccessApiHandler> weak_ptr_factory_{this};
   DISALLOW_COPY_AND_ASSIGN(AccessApiHandler);
diff --git a/src/access_api_handler_unittest.cc b/src/access_api_handler_unittest.cc
index 0a01d4f..fda0748 100644
--- a/src/access_api_handler_unittest.cc
+++ b/src/access_api_handler_unittest.cc
@@ -9,10 +9,10 @@
 #include <weave/test/mock_device.h>
 #include <weave/test/unittest_utils.h>
 
-#include "src/access_black_list_manager.h"
+#include "src/access_revocation_manager.h"
 #include "src/component_manager_impl.h"
 #include "src/data_encoding.h"
-#include "src/test/mock_black_list_manager.h"
+#include "src/test/mock_access_revocation_manager.h"
 
 using testing::_;
 using testing::AnyOf;
@@ -84,7 +84,7 @@ class AccessApiHandlerTest : public ::testing::Test {
   StrictMock<provider::test::FakeTaskRunner> task_runner_;
   ComponentManagerImpl component_manager_{&task_runner_};
   StrictMock<test::MockDevice> device_;
-  StrictMock<test::MockAccessBlackListManager> access_manager_;
+  StrictMock<test::MockAccessRevocationManager> access_manager_;
   std::unique_ptr<AccessApiHandler> handler_;
 };
 
@@ -158,10 +158,10 @@ TEST_F(AccessApiHandlerTest, Initialization) {
 TEST_F(AccessApiHandlerTest, Revoke) {
   EXPECT_CALL(
       access_manager_,
-      Block(AccessBlackListManager::Entry{std::vector<uint8_t>{1, 2, 3},
-                                          std::vector<uint8_t>{3, 4, 5},
-                                          base::Time::FromTimeT(946686034),
-                                          base::Time::FromTimeT(946692690)},
+      Block(AccessRevocationManager::Entry{std::vector<uint8_t>{1, 2, 3},
+                                           std::vector<uint8_t>{3, 4, 5},
+                                           base::Time::FromTimeT(946686034),
+                                           base::Time::FromTimeT(946692690)},
             _))
       .WillOnce(WithArgs<1>(
           Invoke([](const DoneCallback& callback) { callback.Run(nullptr); })));
@@ -185,7 +185,7 @@ TEST_F(AccessApiHandlerTest, Revoke) {
 }
 
 TEST_F(AccessApiHandlerTest, List) {
-  std::vector<AccessBlackListManager::Entry> entries{
+  std::vector<AccessRevocationManager::Entry> entries{
       {{11, 12, 13},
        {21, 22, 23},
        base::Time::FromTimeT(1310000000),
diff --git a/src/access_black_list_manager.h b/src/access_revocation_manager.h
index edbb3f2..6d5bf7b 100644
--- a/src/access_black_list_manager.h
+++ b/src/access_revocation_manager.h
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef LIBWEAVE_SRC_ACCESS_BLACK_LIST_H_
-#define LIBWEAVE_SRC_ACCESS_BLACK_LIST_H_
+#ifndef LIBWEAVE_SRC_ACCESS_REVOCATION_MANAGER_H_
+#define LIBWEAVE_SRC_ACCESS_REVOCATION_MANAGER_H_
 
 #include <vector>
 
@@ -11,7 +11,7 @@
 
 namespace weave {
 
-class AccessBlackListManager {
+class AccessRevocationManager {
  public:
   struct Entry {
     Entry() = default;
@@ -38,7 +38,7 @@ class AccessBlackListManager {
     // Time after which to discard the rule.
     base::Time expiration;
   };
-  virtual ~AccessBlackListManager() = default;
+  virtual ~AccessRevocationManager() = default;
 
   virtual void AddEntryAddedCallback(const base::Closure& callback) = 0;
   virtual void Block(const Entry& entry, const DoneCallback& callback) = 0;
@@ -50,17 +50,17 @@ class AccessBlackListManager {
   virtual size_t GetCapacity() const = 0;
 };
 
-inline bool operator==(const AccessBlackListManager::Entry& l,
-                       const AccessBlackListManager::Entry& r) {
+inline bool operator==(const AccessRevocationManager::Entry& l,
+                       const AccessRevocationManager::Entry& r) {
   return l.revocation == r.revocation && l.expiration == r.expiration &&
          l.user_id == r.user_id && l.app_id == r.app_id;
 }
 
-inline bool operator!=(const AccessBlackListManager::Entry& l,
-                       const AccessBlackListManager::Entry& r) {
+inline bool operator!=(const AccessRevocationManager::Entry& l,
+                       const AccessRevocationManager::Entry& r) {
   return !(l == r);
 }
 
 }  // namespace weave
 
-#endif  // LIBWEAVE_SRC_ACCESS_BLACK_LIST_H_
+#endif  // LIBWEAVE_SRC_ACCESS_REVOCATION_MANAGER_H_
diff --git a/src/access_black_list_manager_impl.cc b/src/access_revocation_manager_impl.cc
index 48c998b..f039114 100644
--- a/src/access_black_list_manager_impl.cc
+++ b/src/access_revocation_manager_impl.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 "src/access_black_list_manager_impl.h"
+#include "src/access_revocation_manager_impl.h"
 
 #include <base/json/json_reader.h>
 #include <base/json/json_writer.h>
@@ -23,7 +23,7 @@ const char kExpiration[] = "expiration";
 const char kRevocation[] = "revocation";
 }
 
-AccessBlackListManagerImpl::AccessBlackListManagerImpl(
+AccessRevocationManagerImpl::AccessRevocationManagerImpl(
     provider::ConfigStore* store,
     size_t capacity,
     base::Clock* clock)
@@ -31,7 +31,7 @@ AccessBlackListManagerImpl::AccessBlackListManagerImpl(
   Load();
 }
 
-void AccessBlackListManagerImpl::Load() {
+void AccessRevocationManagerImpl::Load() {
   if (!store_)
     return;
   if (auto list = base::ListValue::From(
@@ -61,7 +61,7 @@ void AccessBlackListManagerImpl::Load() {
   }
 }
 
-void AccessBlackListManagerImpl::Save(const DoneCallback& callback) {
+void AccessRevocationManagerImpl::Save(const DoneCallback& callback) {
   if (!store_) {
     if (!callback.is_null())
       callback.Run(nullptr);
@@ -83,7 +83,7 @@ void AccessBlackListManagerImpl::Save(const DoneCallback& callback) {
   store_->SaveSettings(kConfigFileName, json, callback);
 }
 
-void AccessBlackListManagerImpl::RemoveExpired() {
+void AccessRevocationManagerImpl::RemoveExpired() {
   for (auto i = begin(entries_); i != end(entries_);) {
     if (i->expiration <= clock_->Now())
       i = entries_.erase(i);
@@ -92,13 +92,13 @@ void AccessBlackListManagerImpl::RemoveExpired() {
   }
 }
 
-void AccessBlackListManagerImpl::AddEntryAddedCallback(
+void AccessRevocationManagerImpl::AddEntryAddedCallback(
     const base::Closure& callback) {
   on_entry_added_callbacks_.push_back(callback);
 }
 
-void AccessBlackListManagerImpl::Block(const Entry& entry,
-                                       const DoneCallback& callback) {
+void AccessRevocationManagerImpl::Block(const Entry& entry,
+                                        const DoneCallback& callback) {
   // Iterating is OK as Save below is more expensive.
   RemoveExpired();
   if (entry.expiration <= clock_->Now()) {
@@ -137,9 +137,9 @@ void AccessBlackListManagerImpl::Block(const Entry& entry,
   Save(callback);
 }
 
-bool AccessBlackListManagerImpl::IsBlocked(const std::vector<uint8_t>& user_id,
-                                           const std::vector<uint8_t>& app_id,
-                                           base::Time timestamp) const {
+bool AccessRevocationManagerImpl::IsBlocked(const std::vector<uint8_t>& user_id,
+                                            const std::vector<uint8_t>& app_id,
+                                            base::Time timestamp) const {
   Entry entry_to_find;
   for (const auto& user : {{}, user_id}) {
     for (const auto& app : {{}, app_id}) {
@@ -155,16 +155,16 @@ bool AccessBlackListManagerImpl::IsBlocked(const std::vector<uint8_t>& user_id,
   return false;
 }
 
-std::vector<AccessBlackListManager::Entry>
-AccessBlackListManagerImpl::GetEntries() const {
+std::vector<AccessRevocationManager::Entry>
+AccessRevocationManagerImpl::GetEntries() const {
   return {begin(entries_), end(entries_)};
 }
 
-size_t AccessBlackListManagerImpl::GetSize() const {
+size_t AccessRevocationManagerImpl::GetSize() const {
   return entries_.size();
 }
 
-size_t AccessBlackListManagerImpl::GetCapacity() const {
+size_t AccessRevocationManagerImpl::GetCapacity() const {
   return capacity_;
 }
 
diff --git a/src/access_black_list_manager_impl.h b/src/access_revocation_manager_impl.h
index ff91a8f..a911128 100644
--- a/src/access_black_list_manager_impl.h
+++ b/src/access_revocation_manager_impl.h
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef LIBWEAVE_SRC_ACCESS_BLACK_LIST_IMPL_H_
-#define LIBWEAVE_SRC_ACCESS_BLACK_LIST_IMPL_H_
+#ifndef LIBWEAVE_SRC_ACCESS_REVOCATION_MANAGER_IMPL_H_
+#define LIBWEAVE_SRC_ACCESS_REVOCATION_MANAGER_IMPL_H_
 
 #include <set>
 #include <utility>
@@ -13,17 +13,17 @@
 #include <weave/error.h>
 #include <weave/provider/config_store.h>
 
-#include "src/access_black_list_manager.h"
+#include "src/access_revocation_manager.h"
 
 namespace weave {
 
-class AccessBlackListManagerImpl : public AccessBlackListManager {
+class AccessRevocationManagerImpl : public AccessRevocationManager {
  public:
-  explicit AccessBlackListManagerImpl(provider::ConfigStore* store,
-                                      size_t capacity = 1024,
-                                      base::Clock* clock = nullptr);
+  explicit AccessRevocationManagerImpl(provider::ConfigStore* store,
+                                       size_t capacity = 1024,
+                                       base::Clock* clock = nullptr);
 
-  // AccessBlackListManager implementation.
+  // AccessRevocationManager implementation.
   void AddEntryAddedCallback(const base::Closure& callback) override;
   void Block(const Entry& entry, const DoneCallback& callback) override;
   bool IsBlocked(const std::vector<uint8_t>& user_id,
@@ -56,9 +56,9 @@ class AccessBlackListManagerImpl : public AccessBlackListManager {
   std::set<Entry, EntryIdsLess> entries_;
   std::vector<base::Closure> on_entry_added_callbacks_;
 
-  DISALLOW_COPY_AND_ASSIGN(AccessBlackListManagerImpl);
+  DISALLOW_COPY_AND_ASSIGN(AccessRevocationManagerImpl);
 };
 
 }  // namespace weave
 
-#endif  // LIBWEAVE_SRC_ACCESS_BLACK_LIST_IMPL_H_
+#endif  // LIBWEAVE_SRC_ACCESS_REVOCATION_MANAGER_IMPL_H_
diff --git a/src/access_black_list_manager_impl_unittest.cc b/src/access_revocation_manager_impl_unittest.cc
index 3be9287..b0b774b 100644
--- a/src/access_black_list_manager_impl_unittest.cc
+++ b/src/access_revocation_manager_impl_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 "src/access_black_list_manager_impl.h"
+#include "src/access_revocation_manager_impl.h"
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
@@ -18,7 +18,7 @@ using testing::StrictMock;
 
 namespace weave {
 
-class AccessBlackListManagerImplTest : public testing::Test {
+class AccessRevocationManagerImplTest : public testing::Test {
  protected:
   void SetUp() {
     std::string to_load = R"([{
@@ -52,17 +52,18 @@ class AccessBlackListManagerImplTest : public testing::Test {
 
     EXPECT_CALL(clock_, Now())
         .WillRepeatedly(Return(base::Time::FromTimeT(1412121212)));
-    manager_.reset(new AccessBlackListManagerImpl{&config_store_, 10, &clock_});
+    manager_.reset(
+        new AccessRevocationManagerImpl{&config_store_, 10, &clock_});
   }
   StrictMock<test::MockClock> clock_;
   StrictMock<provider::test::MockConfigStore> config_store_{false};
-  std::unique_ptr<AccessBlackListManagerImpl> manager_;
+  std::unique_ptr<AccessRevocationManagerImpl> manager_;
 };
 
-TEST_F(AccessBlackListManagerImplTest, Init) {
+TEST_F(AccessRevocationManagerImplTest, Init) {
   EXPECT_EQ(1u, manager_->GetSize());
   EXPECT_EQ(10u, manager_->GetCapacity());
-  EXPECT_EQ((std::vector<AccessBlackListManagerImpl::Entry>{{
+  EXPECT_EQ((std::vector<AccessRevocationManagerImpl::Entry>{{
                 {1, 2, 3},
                 {3, 4, 5},
                 base::Time::FromTimeT(1419997999),
@@ -71,7 +72,7 @@ TEST_F(AccessBlackListManagerImplTest, Init) {
             manager_->GetEntries());
 }
 
-TEST_F(AccessBlackListManagerImplTest, Block) {
+TEST_F(AccessRevocationManagerImplTest, Block) {
   bool callback_called = false;
   manager_->AddEntryAddedCallback(
       base::Bind([&callback_called]() { callback_called = true; }));
@@ -101,7 +102,7 @@ TEST_F(AccessBlackListManagerImplTest, Block) {
   EXPECT_TRUE(callback_called);
 }
 
-TEST_F(AccessBlackListManagerImplTest, BlockExpired) {
+TEST_F(AccessRevocationManagerImplTest, BlockExpired) {
   manager_->Block({{},
                    {},
                    base::Time::FromTimeT(1300000000),
@@ -111,7 +112,7 @@ TEST_F(AccessBlackListManagerImplTest, BlockExpired) {
                   }));
 }
 
-TEST_F(AccessBlackListManagerImplTest, BlockListIsFull) {
+TEST_F(AccessRevocationManagerImplTest, BlockListIsFull) {
   EXPECT_CALL(config_store_, SaveSettings("black_list", _, _))
       .WillRepeatedly(testing::WithArgs<1, 2>(testing::Invoke(
           [](const std::string& json, const DoneCallback& callback) {
@@ -136,23 +137,23 @@ TEST_F(AccessBlackListManagerImplTest, BlockListIsFull) {
                   }));
 }
 
-TEST_F(AccessBlackListManagerImplTest, IsBlockedIdsNotMacth) {
+TEST_F(AccessRevocationManagerImplTest, IsBlockedIdsNotMacth) {
   EXPECT_FALSE(manager_->IsBlocked({7, 7, 7}, {8, 8, 8}, {}));
 }
 
-TEST_F(AccessBlackListManagerImplTest, IsBlockedRevocationIsOld) {
+TEST_F(AccessRevocationManagerImplTest, IsBlockedRevocationIsOld) {
   // Ids match but delegation time is newer than revocation time.
   EXPECT_FALSE(manager_->IsBlocked({1, 2, 3}, {3, 4, 5},
                                    base::Time::FromTimeT(1429997999)));
 }
 
-class AccessBlackListManagerImplIsBlockedTest
-    : public AccessBlackListManagerImplTest,
+class AccessRevocationManagerImplIsBlockedTest
+    : public AccessRevocationManagerImplTest,
       public testing::WithParamInterface<
           std::tuple<std::vector<uint8_t>, std::vector<uint8_t>>> {
  public:
   void SetUp() override {
-    AccessBlackListManagerImplTest::SetUp();
+    AccessRevocationManagerImplTest::SetUp();
     EXPECT_CALL(config_store_, SaveSettings("black_list", _, _))
         .WillOnce(testing::WithArgs<2>(
             testing::Invoke([](const DoneCallback& callback) {
@@ -167,13 +168,13 @@ class AccessBlackListManagerImplIsBlockedTest
   }
 };
 
-TEST_P(AccessBlackListManagerImplIsBlockedTest, IsBlocked) {
+TEST_P(AccessRevocationManagerImplIsBlockedTest, IsBlocked) {
   EXPECT_TRUE(manager_->IsBlocked({7, 7, 7}, {8, 8, 8}, {}));
 }
 
 INSTANTIATE_TEST_CASE_P(
     Filters,
-    AccessBlackListManagerImplIsBlockedTest,
+    AccessRevocationManagerImplIsBlockedTest,
     testing::Combine(testing::Values(std::vector<uint8_t>{},
                                      std::vector<uint8_t>{7, 7, 7}),
                      testing::Values(std::vector<uint8_t>{},
diff --git a/src/device_manager.cc b/src/device_manager.cc
index 7e72b31..b6b91a9 100644
--- a/src/device_manager.cc
+++ b/src/device_manager.cc
@@ -9,7 +9,7 @@
 #include <base/bind.h>
 
 #include "src/access_api_handler.h"
-#include "src/access_black_list_manager_impl.h"
+#include "src/access_revocation_manager_impl.h"
 #include "src/base_api_handler.h"
 #include "src/commands/schema_constants.h"
 #include "src/component_manager_impl.h"
@@ -33,12 +33,13 @@ DeviceManager::DeviceManager(provider::ConfigStore* config_store,
     : config_{new Config{config_store}},
       component_manager_{new ComponentManagerImpl{task_runner}} {
   if (http_server) {
-    black_list_manager_.reset(new AccessBlackListManagerImpl{config_store});
+    access_revocation_manager_.reset(
+        new AccessRevocationManagerImpl{config_store});
     auth_manager_.reset(
-        new privet::AuthManager(config_.get(), black_list_manager_.get(),
+        new privet::AuthManager(config_.get(), access_revocation_manager_.get(),
                                 http_server->GetHttpsCertificateFingerprint()));
     access_api_handler_.reset(
-        new AccessApiHandler{this, black_list_manager_.get()});
+        new AccessApiHandler{this, access_revocation_manager_.get()});
   }
 
   device_info_.reset(new DeviceRegistrationInfo(
diff --git a/src/device_manager.h b/src/device_manager.h
index a089e7a..545f293 100644
--- a/src/device_manager.h
+++ b/src/device_manager.h
@@ -11,7 +11,7 @@
 namespace weave {
 
 class AccessApiHandler;
-class AccessBlackListManager;
+class AccessRevocationManager;
 class BaseApiHandler;
 class Config;
 class ComponentManager;
@@ -93,7 +93,7 @@ class DeviceManager final : public Device {
   std::unique_ptr<ComponentManager> component_manager_;
   std::unique_ptr<DeviceRegistrationInfo> device_info_;
   std::unique_ptr<BaseApiHandler> base_api_handler_;
-  std::unique_ptr<AccessBlackListManager> black_list_manager_;
+  std::unique_ptr<AccessRevocationManager> access_revocation_manager_;
   std::unique_ptr<AccessApiHandler> access_api_handler_;
   std::unique_ptr<privet::Manager> privet_;
 
diff --git a/src/privet/auth_manager.cc b/src/privet/auth_manager.cc
index ddead46..d905a45 100644
--- a/src/privet/auth_manager.cc
+++ b/src/privet/auth_manager.cc
@@ -11,7 +11,7 @@
 #include <base/rand_util.h>
 #include <base/strings/string_number_conversions.h>
 
-#include "src/access_black_list_manager.h"
+#include "src/access_revocation_manager.h"
 #include "src/config.h"
 #include "src/data_encoding.h"
 #include "src/privet/constants.h"
@@ -269,7 +269,7 @@ AuthScope FromMacaroonScope(uint32_t scope) {
 }  // namespace
 
 AuthManager::AuthManager(Config* config,
-                         AccessBlackListManager* black_list,
+                         AccessRevocationManager* black_list,
                          const std::vector<uint8_t>& certificate_fingerprint)
     : config_{config},
       black_list_{black_list},
@@ -291,7 +291,7 @@ AuthManager::AuthManager(const std::vector<uint8_t>& auth_secret,
                          const std::vector<uint8_t>& certificate_fingerprint,
                          const std::vector<uint8_t>& access_secret,
                          base::Clock* clock,
-                         AccessBlackListManager* black_list)
+                         AccessRevocationManager* black_list)
     : AuthManager(nullptr, black_list, certificate_fingerprint) {
   access_secret_ = access_secret.size() == kSha256OutputSize ? access_secret
                                                              : CreateSecret();
diff --git a/src/privet/auth_manager.h b/src/privet/auth_manager.h
index 83899da..d8174f6 100644
--- a/src/privet/auth_manager.h
+++ b/src/privet/auth_manager.h
@@ -19,7 +19,7 @@
 
 namespace weave {
 
-class AccessBlackListManager;
+class AccessRevocationManager;
 class Config;
 enum class RootClientTokenOwner;
 
@@ -28,7 +28,7 @@ namespace privet {
 class AuthManager {
  public:
   AuthManager(Config* config,
-              AccessBlackListManager* black_list,
+              AccessRevocationManager* black_list,
               const std::vector<uint8_t>& certificate_fingerprint);
 
   // Constructor for tests.
@@ -36,7 +36,7 @@ class AuthManager {
               const std::vector<uint8_t>& certificate_fingerprint,
               const std::vector<uint8_t>& access_secret,
               base::Clock* clock = nullptr,
-              AccessBlackListManager* black_list = nullptr);
+              AccessRevocationManager* black_list = nullptr);
   ~AuthManager();
 
   std::vector<uint8_t> CreateAccessToken(const UserInfo& user_info,
@@ -86,7 +86,7 @@ class AuthManager {
                                       const UserInfo& user_info) const;
 
   Config* config_{nullptr};  // Can be nullptr for tests.
-  AccessBlackListManager* black_list_{nullptr};
+  AccessRevocationManager* black_list_{nullptr};
   base::DefaultClock default_clock_;
   base::Clock* clock_{&default_clock_};
   mutable uint32_t session_counter_{0};
diff --git a/src/privet/auth_manager_unittest.cc b/src/privet/auth_manager_unittest.cc
index f2c8728..648027d 100644
--- a/src/privet/auth_manager_unittest.cc
+++ b/src/privet/auth_manager_unittest.cc
@@ -11,7 +11,7 @@
 #include "src/config.h"
 #include "src/data_encoding.h"
 #include "src/privet/mock_delegates.h"
-#include "src/test/mock_black_list_manager.h"
+#include "src/test/mock_access_revocation_manager.h"
 #include "src/test/mock_clock.h"
 
 using testing::_;
@@ -22,9 +22,9 @@ using testing::StrictMock;
 namespace weave {
 namespace privet {
 
-class MockBlackListManager : public test::MockAccessBlackListManager {
+class MockAccessRevocationManager : public test::MockAccessRevocationManager {
  public:
-  MockBlackListManager() {
+  MockAccessRevocationManager() {
     EXPECT_CALL(*this, AddEntryAddedCallback(_))
         .WillOnce(SaveArg<0>(&changed_callback_));
     EXPECT_CALL(*this, IsBlocked(_, _, _)).WillRepeatedly(Return(false));
@@ -61,7 +61,7 @@ class AuthManagerTest : public testing::Test {
       60, 62, 10, 18, 82, 35, 88, 100, 30, 45, 7, 46, 67, 84, 58, 85};
 
   test::MockClock clock_;
-  StrictMock<MockBlackListManager> black_list_;
+  StrictMock<MockAccessRevocationManager> black_list_;
   AuthManager auth_{kSecret1, kFingerprint, kSecret2, &clock_, &black_list_};
 };
 
diff --git a/src/test/mock_black_list_manager.h b/src/test/mock_access_revocation_manager.h
index 2f6d7eb..29e3721 100644
--- a/src/test/mock_black_list_manager.h
+++ b/src/test/mock_access_revocation_manager.h
@@ -2,18 +2,18 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef LIBWEAVE_SRC_MOCK_BLACK_LIST_MANAGER_H_
-#define LIBWEAVE_SRC_MOCK_BLACK_LIST_MANAGER_H_
+#ifndef LIBWEAVE_SRC_MOCK_ACCESS_REVOCATION_MANAGER_H_
+#define LIBWEAVE_SRC_MOCK_ACCESS_REVOCATION_MANAGER_H_
 
 #include <gmock/gmock.h>
 
-#include "src/access_black_list_manager.h"
+#include "src/access_revocation_manager.h"
 
 namespace weave {
 
 namespace test {
 
-class MockAccessBlackListManager : public AccessBlackListManager {
+class MockAccessRevocationManager : public AccessRevocationManager {
  public:
   MOCK_METHOD1(AddEntryAddedCallback, void(const base::Closure&));
   MOCK_METHOD2(Block, void(const Entry&, const DoneCallback&));
@@ -30,4 +30,4 @@ class MockAccessBlackListManager : public AccessBlackListManager {
 
 }  // namespace weave
 
-#endif  // LIBWEAVE_SRC_MOCK_BLACK_LIST_MANAGER_H_
+#endif  // LIBWEAVE_SRC_MOCK_ACCESS_REVOCATION_MANAGER_H_