Remove explicit singletonness of ArcBridgeService part 4.

chrome/browser/chromeos/arc/arc_session_manager_unittest.cc

 // Copyright 2016 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 <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 27 matching lines @@
 #include "components/user_manager/user_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "google_apis/gaia/gaia_urls.h"
 #include "net/http/http_status_code.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace arc {
 
-class ArcSessionManagerTest : public testing::Test {
+class ArcSessionManagerTestBase : public testing::Test {
  public:
-  ArcSessionManagerTest()
+  ArcSessionManagerTestBase()
       : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP),
-        user_manager_enabler_(new chromeos::FakeChromeUserManager) {}
-  ~ArcSessionManagerTest() override = default;
+        user_manager_enabler_(new chromeos::FakeChromeUserManager()) {}
+  ~ArcSessionManagerTestBase() override = default;
 
   void SetUp() override {
     chromeos::DBusThreadManager::Initialize();
 
     base::CommandLine::ForCurrentProcess()->AppendSwitch(
         chromeos::switches::kEnableArc);
     ArcSessionManager::DisableUIForTesting();
 
     EXPECT_TRUE(temp_dir_.CreateUniqueTempDir());
     TestingProfile::Builder profile_builder;
+    profile_builder.SetProfileName("user@gmail.com");
     profile_builder.SetPath(temp_dir_.GetPath().AppendASCII("TestArcProfile"));
 
     profile_ = profile_builder.Build();
     StartPreferenceSyncing();
 
     bridge_service_.reset(new FakeArcBridgeService());
     arc_session_manager_.reset(new ArcSessionManager(bridge_service_.get()));
 
     // Check initial conditions.
     EXPECT_EQ(bridge_service_.get(), ArcBridgeService::Get());
     EXPECT_TRUE(ArcBridgeService::Get()->stopped());
 
-    const AccountId account_id(
-        AccountId::FromUserEmailGaiaId("user@gmail.com", "1234567890"));
-    GetFakeUserManager()->AddUser(account_id);
-    GetFakeUserManager()->LoginUser(account_id);
-
     chromeos::WallpaperManager::Initialize();
   }
 
   void TearDown() override {
     chromeos::WallpaperManager::Shutdown();
     chromeos::DBusThreadManager::Shutdown();
   }
 
   chromeos::FakeChromeUserManager* GetFakeUserManager() const {
     return static_cast<chromeos::FakeChromeUserManager*>(
         user_manager::UserManager::Get());
   }
 
  protected:
   Profile* profile() { return profile_.get(); }
   FakeArcBridgeService* bridge_service() { return bridge_service_.get(); }
   ArcSessionManager* arc_session_manager() {
     return arc_session_manager_.get();
   }
 
  private:
   void StartPreferenceSyncing() const {
     PrefServiceSyncableFromProfile(profile_.get())
         ->GetSyncableService(syncer::PREFERENCES)
-        ->MergeDataAndStartSyncing(syncer::PREFERENCES, syncer::SyncDataList(),
-                                   std::unique_ptr<syncer::SyncChangeProcessor>(
-                                       new syncer::FakeSyncChangeProcessor),
-                                   std::unique_ptr<syncer::SyncErrorFactory>(
-                                       new syncer::SyncErrorFactoryMock()));
+        ->MergeDataAndStartSyncing(
+            syncer::PREFERENCES, syncer::SyncDataList(),
+            base::MakeUnique<syncer::FakeSyncChangeProcessor>(),
+            base::MakeUnique<syncer::SyncErrorFactoryMock>());
   }
 
   content::TestBrowserThreadBundle thread_bundle_;
   std::unique_ptr<FakeArcBridgeService> bridge_service_;
   std::unique_ptr<TestingProfile> profile_;
   std::unique_ptr<ArcSessionManager> arc_session_manager_;
   chromeos::ScopedUserManagerEnabler user_manager_enabler_;
   base::ScopedTempDir temp_dir_;
 
+  DISALLOW_COPY_AND_ASSIGN(ArcSessionManagerTestBase);
+};
+
+class ArcSessionManagerTest : public ArcSessionManagerTestBase {
+ public:
+  ArcSessionManagerTest() = default;
+
+  void SetUp() override {
+    ArcSessionManagerTestBase::SetUp();
+
+    const AccountId account_id(AccountId::FromUserEmailGaiaId(
+        profile()->GetProfileUserName(), "1234567890"));
+    GetFakeUserManager()->AddUser(account_id);
+    GetFakeUserManager()->LoginUser(account_id);
+  }
+
+ private:
   DISALLOW_COPY_AND_ASSIGN(ArcSessionManagerTest);
 };
 
 TEST_F(ArcSessionManagerTest, PrefChangeTriggersService) {
   ASSERT_EQ(ArcSessionManager::State::NOT_INITIALIZED,
             arc_session_manager()->state());
 
   PrefService* const pref = profile()->GetPrefs();
   ASSERT_FALSE(pref->GetBoolean(prefs::kArcEnabled));
 
@@ skipping 241 matching lines @@
   GetFakeUserManager()->SwitchActiveUser(account_id);
   second_profile->GetPrefs()->SetBoolean(prefs::kArcEnabled, true);
 
   // Check that non-primary user can't use Arc.
   EXPECT_FALSE(chromeos::ProfileHelper::IsPrimaryProfile(second_profile.get()));
   EXPECT_FALSE(ArcAppListPrefs::Get(second_profile.get()));
 
   arc_session_manager()->Shutdown();
 }
 
+class ArcSessionManagerKioskTest : public ArcSessionManagerTestBase {
+ public:
+  ArcSessionManagerKioskTest() = default;
+
+  void SetUp() override {
+    ArcSessionManagerTestBase::SetUp();
+    const AccountId account_id(
+        AccountId::FromUserEmail(profile()->GetProfileUserName()));
+    GetFakeUserManager()->AddArcKioskAppUser(account_id);
+    GetFakeUserManager()->LoginUser(account_id);
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ArcSessionManagerKioskTest);
+};
+
+TEST_F(ArcSessionManagerKioskTest, AuthFailure) {
+  profile()->GetPrefs()->SetBoolean(prefs::kArcEnabled, true);
+  arc_session_manager()->OnPrimaryUserProfilePrepared(profile());
+  EXPECT_EQ(ArcSessionManager::State::ACTIVE, arc_session_manager()->state());
+
+  // Replace chrome::AttemptUserExit() for testing.
+  // At the end of test, we leave the dangling pointer |terminated|,

[Luis Héctor Chávez, 2016/12/06 19:08:56]

I don't understand this comment. You are calling EXPECT_TRUE(terminated) in
L422. Given that you set |terminated = false|  in L416, you are expecting the
callback to be invoked. There is no dangling pointer involved since the callback
would not be invoked again.

[hidehiko, 2016/12/08 14:29:33]

The attempt_user_exit_callback_ in ArcSessionManager instance still keeps the
pointer to |terminated|, even after the test scenario, e.g. TearDown(), which is
a dangling pointer.
I just assumed that attempt_user_exit_callback_ will never be called, so that we
can TearDown() safely.

+  // assuming the callback will never be called.
+  bool terminated = false;
+  arc_session_manager()->SetAttemptUserExitCallbackForTesting(
+      base::Bind([](bool* terminated) { *terminated = true; }, &terminated));
+
+  arc_session_manager()->OnProvisioningFinished(
+      ProvisioningResult::CHROME_SERVER_COMMUNICATION_ERROR);
+  EXPECT_TRUE(terminated);
+}
+
 }  // namespace arc