Introduce ash mojo interface for lock screen action handlers

ash/action_handler/action_handler_state_controller_unittest.cc

Index: ash/action_handler/action_handler_state_controller_unittest.cc
diff --git a/ash/action_handler/action_handler_state_controller_unittest.cc b/ash/action_handler/action_handler_state_controller_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..38177487e10156a50fd596eeb1a49d5a408c4539
--- /dev/null
+++ b/ash/action_handler/action_handler_state_controller_unittest.cc
@@ -0,0 +1,186 @@
+// 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 <vector>
+
+#include "ash/action_handler/action_handler_state_controller.h"
+#include "ash/action_handler/action_handler_state_observer.h"
+#include "ash/shell.h"
+#include "ash/test/ash_test_base.h"
+#include "base/macros.h"
+#include "base/memory/ptr_util.h"
+
+namespace ash {
+
+namespace {
+
+class ScopedTestStateObserver : public ActionHandlerStateObserver {
+ public:
+  explicit ScopedTestStateObserver(ActionHandlerStateController* controller)
+      : state_controller_(controller) {
+    state_controller_->AddObserver(this);
+  }
+
+  ~ScopedTestStateObserver() override {
+    state_controller_->RemoveObserver(this);
+  }
+
+  void OnActionStateChanged(mojom::ActionHandlerAction action,
+                            mojom::ActionHandlerState state) override {
+    ASSERT_EQ(mojom::ActionHandlerAction::kNewNote, action);
+
+    observed_states_.push_back(state);
+  }
+
+  const std::vector<mojom::ActionHandlerState>& observed_states() const {
+    return observed_states_;
+  }
+
+  void ClearObservedStates() { observed_states_.clear(); }
+
+ private:
+  ActionHandlerStateController* state_controller_;
+
+  std::vector<mojom::ActionHandlerState> observed_states_;
+
+  DISALLOW_COPY_AND_ASSIGN(ScopedTestStateObserver);
+};
+
+class ScopedTestActionHandler : public mojom::ActionHandler {
+ public:
+  explicit ScopedTestActionHandler(ActionHandlerStateController* controller)
+      : state_controller_(controller), binding_(this) {
+    state_controller_->SetActionHandler(binding_.CreateInterfacePtrAndBind());
+  }
+
+  ~ScopedTestActionHandler() override {
+    state_controller_->SetActionHandler(nullptr);
+  }
+
+  void RequestHandleAction(ash::mojom::ActionHandlerAction action) override {
+    ASSERT_EQ(mojom::ActionHandlerAction::kNewNote, action);
+
+    LOG(ERROR) << "HANDLE ACTION";
+    action_requests_count_++;
+  }
+
+  int action_requests_count() const { return action_requests_count_; }
+
+  void reset_action_requests_count() { action_requests_count_ = 0; }
+
+ private:
+  ActionHandlerStateController* state_controller_;
+  mojo::Binding<ash::mojom::ActionHandler> binding_;
+
+  int action_requests_count_ = 0;
+
+  DISALLOW_COPY_AND_ASSIGN(ScopedTestActionHandler);
+};
+
+class ActionHandlerStateControllerTest : public test::AshTestBase {
+ public:
+  ActionHandlerStateControllerTest() {}
+  ~ActionHandlerStateControllerTest() override {}
+
+  ActionHandlerStateController* GetController() {
+    return Shell::Get()->action_handler_state_controller();
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ActionHandlerStateControllerTest);
+};
+
+}  // namespace
+
+TEST_F(ActionHandlerStateControllerTest, NoActionHandler) {
+  ActionHandlerStateController* controller = GetController();
+  ScopedTestStateObserver observer(controller);
+
+  EXPECT_EQ(mojom::ActionHandlerState::kNotSupported,
+            controller->GetState(mojom::ActionHandlerAction::kNewNote));
+
+  controller->UpdateActionState(mojom::ActionHandlerAction::kNewNote,
+                                mojom::ActionHandlerState::kAvailable);
+
+  // The effective state should be |kNotSupported| as long as an action handler
+  // is not set.
+  EXPECT_EQ(mojom::ActionHandlerState::kNotSupported,
+            controller->GetState(mojom::ActionHandlerAction::kNewNote));
+  EXPECT_EQ(0u, observer.observed_states().size());
+
+  // Adding action handler should update the controller state.
+  std::unique_ptr<ScopedTestActionHandler> scoped_action_handler =
+      base::MakeUnique<ScopedTestActionHandler>(controller);
+
+  EXPECT_EQ(mojom::ActionHandlerState::kAvailable,
+            controller->GetState(mojom::ActionHandlerAction::kNewNote));
+  // Effective state changed, so observer should be notified of it.
+  ASSERT_EQ(1u, observer.observed_states().size());
+  EXPECT_EQ(mojom::ActionHandlerState::kAvailable,
+            observer.observed_states()[0]);
+  observer.ClearObservedStates();
+
+  // When action handler is reset, effective state should go back to
+  // |kNotSupported|.
+  scoped_action_handler.reset();
+
+  EXPECT_EQ(mojom::ActionHandlerState::kNotSupported,
+            controller->GetState(mojom::ActionHandlerAction::kNewNote));
+  // Effective state changed, so observer should be notified of it.
+  ASSERT_EQ(1u, observer.observed_states().size());
+  EXPECT_EQ(mojom::ActionHandlerState::kNotSupported,
+            observer.observed_states()[0]);
+  observer.ClearObservedStates();
+}
+
+TEST_F(ActionHandlerStateControllerTest, StateChangesWithHandlerSet) {
+  ActionHandlerStateController* controller = GetController();
+
+  ScopedTestStateObserver observer(controller);
+  ScopedTestActionHandler action_handler(controller);
+
+  controller->UpdateActionState(mojom::ActionHandlerAction::kNewNote,
+                                mojom::ActionHandlerState::kAvailable);
+  EXPECT_EQ(mojom::ActionHandlerState::kAvailable,
+            controller->GetState(mojom::ActionHandlerAction::kNewNote));
+  ASSERT_EQ(1u, observer.observed_states().size());
+  EXPECT_EQ(mojom::ActionHandlerState::kAvailable,
+            observer.observed_states()[0]);
+  observer.ClearObservedStates();
+
+  controller->UpdateActionState(mojom::ActionHandlerAction::kNewNote,
+                                mojom::ActionHandlerState::kAvailable);
+  EXPECT_EQ(mojom::ActionHandlerState::kAvailable,
+            controller->GetState(mojom::ActionHandlerAction::kNewNote));
+  // No real state change, so the observer should not be notified.
+  ASSERT_EQ(0u, observer.observed_states().size());
+
+  controller->UpdateActionState(mojom::ActionHandlerAction::kNewNote,
+                                mojom::ActionHandlerState::kActive);
+  EXPECT_EQ(mojom::ActionHandlerState::kActive,
+            controller->GetState(mojom::ActionHandlerAction::kNewNote));
+  ASSERT_EQ(1u, observer.observed_states().size());
+  EXPECT_EQ(mojom::ActionHandlerState::kActive, observer.observed_states()[0]);
+  observer.ClearObservedStates();
+}
+
+TEST_F(ActionHandlerStateControllerTest, RequestAction) {
+  ActionHandlerStateController* controller = GetController();
+
+  ScopedTestActionHandler action_handler(controller);
+
+  EXPECT_EQ(0, action_handler.action_requests_count());
+  controller->RequestHandleAction(mojom::ActionHandlerAction::kNewNote);
+  RunAllPendingInMessageLoop();
+  EXPECT_EQ(1, action_handler.action_requests_count());
+}
+
+// Tests that there is no crash if handler is not set.
+TEST_F(ActionHandlerStateControllerTest, RequestActionWithNoHandler) {
+  ActionHandlerStateController* controller = GetController();
+  controller->RequestHandleAction(mojom::ActionHandlerAction::kNewNote);
+}
+
+}  // namespace ash