Supprot V2 app: step1

athena/env/athena_env_unittest.cc

 // Copyright 2014 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 "athena/env/public/athena_env.h"
 
 #include "athena/test/athena_test_base.h"
 #include "base/bind.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/screen.h"
 
 namespace athena {
 
+typedef test::AthenaTestBase AthenaEnvTest;
+
+namespace {
+
+class TerminatingCallback {
+ public:
+  TerminatingCallback()
+      : on_terminating_count_(0),
+        on_terminating_2_count_(0) {
+  }
+
+  void OnTerminating() {
+    on_terminating_count_ ++;
+  }
+
+  void OnTerminating2() {
+    on_terminating_2_count_ ++;
+  }
+
+  int on_terminating_count() const { return on_terminating_count_; }
+  int on_terminating_2_count() const { return on_terminating_2_count_; }
+
+  void Reset() {
+    on_terminating_count_ = 0;
+    on_terminating_2_count_ = 0;
+  }
+
+ private:
+  int on_terminating_count_;
+  int on_terminating_2_count_;
+
+  DISALLOW_COPY_AND_ASSIGN(TerminatingCallback);
+};
+
+}  // namespace
+
+TEST_F(AthenaEnvTest, TerminatingCallback) {
+  TerminatingCallback callback_1;
+  TerminatingCallback callback_2;
+  AthenaEnv* env = AthenaEnv::Get();
+  base::Closure cb_1_1 =
+      base::Bind(&TerminatingCallback::OnTerminating,
+                 base::Unretained(&callback_1));
+  base::Closure cb_1_2 =
+      base::Bind(&TerminatingCallback::OnTerminating2,
+                 base::Unretained(&callback_1));
+  base::Closure cb_2_1 =
+      base::Bind(&TerminatingCallback::OnTerminating,
+                 base::Unretained(&callback_2));
+
+  env->AddTerminatingCallback(cb_1_1);
+  env->AddTerminatingCallback(cb_1_2);
+  env->AddTerminatingCallback(cb_2_1);
+  env->OnTerminating();
+
+  EXPECT_EQ(1, callback_1.on_terminating_count());
+  EXPECT_EQ(1, callback_1.on_terminating_2_count());
+  EXPECT_EQ(1, callback_2.on_terminating_count());
+
+  // Remove callbacks.
+  callback_1.Reset();
+  callback_2.Reset();
+  env->RemoveTerminatingCallback(cb_1_2);
+  env->OnTerminating();
+  EXPECT_EQ(1, callback_1.on_terminating_count());
+  EXPECT_EQ(0, callback_1.on_terminating_2_count());
+  EXPECT_EQ(1, callback_2.on_terminating_count());
+
+  callback_1.Reset();
+  callback_2.Reset();
+  env->RemoveTerminatingCallback(cb_1_1);
+  env->OnTerminating();
+  EXPECT_EQ(0, callback_1.on_terminating_count());
+  EXPECT_EQ(0, callback_1.on_terminating_2_count());
+  EXPECT_EQ(1, callback_2.on_terminating_count());
+
+  // Add removed callback.
+  callback_1.Reset();
+  callback_2.Reset();
+  env->AddTerminatingCallback(cb_1_2);
+  env->OnTerminating();
+  EXPECT_EQ(0, callback_1.on_terminating_count());
+  EXPECT_EQ(1, callback_1.on_terminating_2_count());
+  EXPECT_EQ(1, callback_2.on_terminating_count());
+
+  // Adding empty callback should not fail.
+  env->AddTerminatingCallback(base::Closure());
+  env->OnTerminating();
+}
+
 namespace {
 
 class AthenaShutdownTest : public test::AthenaTestBase {
  public:
   AthenaShutdownTest() {}
   virtual ~AthenaShutdownTest() {}
 
   virtual void TearDown() {
     test::AthenaTestBase::TearDown();
     ASSERT_NE(
         gfx::Display::kInvalidDisplayID,
         gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().id());
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AthenaShutdownTest);
 };
 
-}  // namespace athena
+}  // namespace
 
 // gfx::Screen should be accessible after shutdown.
 TEST_F(AthenaShutdownTest, Shutdown) {
 }
 
 }  // namespace athena