components/arc/arc_service_manager_unittest.cc

// Copyright 2017 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <memory>
#include <utility>

#include "base/auto_reset.h"
#include "base/memory/ptr_util.h"
#include "components/arc/arc_bridge_service.h"
#include "components/arc/arc_service_manager.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace arc {

namespace {

class AnonymousService : public ArcService {
 public:
  AnonymousService(ArcBridgeService* arc_bridge_service, bool* alive)
      : ArcService(arc_bridge_service), alive_(alive, true) {}
  ~AnonymousService() override = default;

 private:
  base::AutoReset<bool> alive_;
};

class NamedService : public ArcService {
 public:
  static const char kArcServiceName[];
  NamedService(ArcBridgeService* arc_bridge_service, bool* alive)
      : ArcService(arc_bridge_service), alive_(alive, true) {}
  ~NamedService() override = default;

 private:
  base::AutoReset<bool> alive_;
};

class DifferentNamedService : public ArcService {
 public:
  static const char kArcServiceName[];
  DifferentNamedService(ArcBridgeService* arc_bridge_service, bool* alive)
      : ArcService(arc_bridge_service), alive_(alive, true) {}
  ~DifferentNamedService() override = default;

 private:
  base::AutoReset<bool> alive_;
};

class EmptyNamedService : public ArcService {
 public:
  static const char kArcServiceName[];
  EmptyNamedService(ArcBridgeService* arc_bridge_service, bool* alive)
      : ArcService(arc_bridge_service), alive_(alive, true) {}
  ~EmptyNamedService() override = default;

 private:
  base::AutoReset<bool> alive_;
};

const char NamedService::kArcServiceName[] =
    "arc::(anonymous namespace)::NamedService";

const char DifferentNamedService::kArcServiceName[] =
    "arc::(anonymous namespace)::DifferentNamedService";

const char EmptyNamedService::kArcServiceName[] = "";

}  // namespace

class ArcServiceManagerTest : public testing::Test {
 public:
  ArcServiceManagerTest() = default;

  void SetUp() override {
    arc_bridge_service_ = base::MakeUnique<ArcBridgeService>();
  }

  void TearDown() override { arc_bridge_service_.reset(); }

  ArcBridgeService* arc_bridge_service() { return arc_bridge_service_.get(); }

 private:
  std::unique_ptr<ArcBridgeService> arc_bridge_service_;

  DISALLOW_COPY_AND_ASSIGN(ArcServiceManagerTest);
};

// Exercises the basic getter functionality of ArcServiceManager.
TEST_F(ArcServiceManagerTest, BasicGetter) {
  bool named_service_alive = false;

  // ArcServiceManager is empty, GetService() should return nullptr.
  auto manager = base::MakeUnique<ArcServiceManager>(nullptr);
  EXPECT_EQ(nullptr, manager->GetService<NamedService>());

  EXPECT_TRUE(manager->AddService(base::MakeUnique<NamedService>(
      arc_bridge_service(), &named_service_alive)));
  EXPECT_TRUE(named_service_alive);
  EXPECT_NE(nullptr, manager->GetService<NamedService>());

  // Finally, the service should not be alive anymore.
  manager.reset();
  EXPECT_FALSE(named_service_alive);
}

// There is no way to distinguish between anonymous services, so it should be
// possible to add them twice (not that it's recommended).
TEST_F(ArcServiceManagerTest, MultipleAnonymousServices) {
  bool anonymous_service_alive = false;
  bool second_anonymous_service_alive = false;

  auto manager = base::MakeUnique<ArcServiceManager>(nullptr);

  EXPECT_TRUE(manager->AddService(base::MakeUnique<AnonymousService>(
      arc_bridge_service(), &anonymous_service_alive)));
  EXPECT_TRUE(anonymous_service_alive);
  EXPECT_TRUE(manager->AddService(base::MakeUnique<AnonymousService>(
      arc_bridge_service(), &second_anonymous_service_alive)));
  EXPECT_TRUE(second_anonymous_service_alive);

  // Finally, the individual services should not be alive anymore.
  manager.reset();
  EXPECT_FALSE(anonymous_service_alive);
  EXPECT_FALSE(second_anonymous_service_alive);
}

// Named services can only be added once, but can still be retrieved.
TEST_F(ArcServiceManagerTest, MultipleNamedServices) {
  bool named_service_alive = false;
  bool second_named_service_alive = false;
  bool different_named_service_alive = false;

  auto manager = base::MakeUnique<ArcServiceManager>(nullptr);

  auto named_service = base::MakeUnique<NamedService>(arc_bridge_service(),
                                                      &named_service_alive);
  NamedService* raw_named_service = named_service.get();
  EXPECT_TRUE(named_service_alive);
  EXPECT_TRUE(manager->AddService(std::move(named_service)));
  auto second_named_service = base::MakeUnique<NamedService>(
      arc_bridge_service(), &second_named_service_alive);
  EXPECT_TRUE(second_named_service_alive);
  // This will fail and immediately destroy the service.
  EXPECT_FALSE(manager->AddService(std::move(second_named_service)));
  EXPECT_FALSE(second_named_service_alive);

  // We should still be able to add a different-named service.
  auto different_named_service = base::MakeUnique<DifferentNamedService>(
      arc_bridge_service(), &different_named_service_alive);
  DifferentNamedService* raw_different_named_service =
      different_named_service.get();
  EXPECT_TRUE(different_named_service_alive);
  EXPECT_TRUE(manager->AddService(std::move(different_named_service)));

  // And find both.
  EXPECT_EQ(raw_named_service, manager->GetService<NamedService>());
  EXPECT_EQ(raw_different_named_service,
            manager->GetService<DifferentNamedService>());

  manager.reset();
  EXPECT_FALSE(named_service_alive);
  EXPECT_FALSE(different_named_service_alive);
}

// Named services with an empty name are treated as anonymous services.
// Developers shouldn't do that, though, and will trigger an error log.
TEST_F(ArcServiceManagerTest, EmptyNamedServices) {
  bool empty_named_service_alive = false;

  auto manager = base::MakeUnique<ArcServiceManager>(nullptr);

  EXPECT_TRUE(manager->AddService(base::MakeUnique<EmptyNamedService>(
      arc_bridge_service(), &empty_named_service_alive)));
  EXPECT_TRUE(empty_named_service_alive);
  EXPECT_EQ(nullptr, manager->GetService<EmptyNamedService>());

  manager.reset();
  EXPECT_FALSE(empty_named_service_alive);
}

// Tests if GetGlobalService works as expected regardless of whether the
// global pointer is null.
TEST_F(ArcServiceManagerTest, TestGetGlobalService) {
  // The getter should return nullptr when no global instance is available.
  EXPECT_EQ(nullptr, ArcServiceManager::GetGlobalService<NamedService>());

  // Create a manager. This will automatically be registered as a global
  // instance.
  auto manager = base::MakeUnique<ArcServiceManager>(nullptr);

  // The getter should return nullptr when the manager doesn't know about the
  // NamedService instance.
  EXPECT_EQ(nullptr, ArcServiceManager::GetGlobalService<NamedService>());

  // Register the instance and retry. The getter should return non-null this
  // time.
  bool unused;
  EXPECT_TRUE(manager->AddService(base::MakeUnique<NamedService>(
      arc_bridge_service(), &unused)));
  EXPECT_NE(nullptr, ArcServiceManager::GetGlobalService<NamedService>());

  // Remove the global instance. The same GetGlobalService() call should return
  // nullptr now.
  manager.reset();
  EXPECT_EQ(nullptr, ArcServiceManager::GetGlobalService<NamedService>());
}

}  // namespace arc