Enable signed-out libassistant for ambient mode.

This change enables the mode switch between signed-in and signed-out
for Liassbistant when user enters/exits the ambient mode, so that we
can further explore the behavior of signed-out mode.

Bug: none.
Test: run unittest added in this change
Change-Id: Idcb4903401173b8f86a3428a0f452b5ce9b7a5ac
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1995804
Commit-Queue: Meilin Wang <meilinw@chromium.org>
Reviewed-by: Xiaohui Chen <xiaohuic@chromium.org>
Reviewed-by: Tao Wu <wutao@chromium.org>
Cr-Commit-Position: refs/heads/master@{#737011}

chromeos/services/assistant/BUILD.gn

@@ -139,6 +139,7 @@ source_set("tests") {
     "//base",
     "//base/test:test_support",
     "//chromeos/audio",
+    "//chromeos/constants",
     "//chromeos/dbus:test_support",
     "//chromeos/dbus/power",
     "//chromeos/services/assistant/public/cpp:prefs",

chromeos/services/assistant/assistant_manager_service.h

@@ -44,7 +44,7 @@ class COMPONENT_EXPORT(ASSISTANT_SERVICE) AssistantManagerService
 
   ~AssistantManagerService() override = default;
 
-  // Start the assistant in the background with |access_token|, where the
+  // Start the Assistant in the background with |access_token|, where the
   // token can be nullopt when the service is being started under the signed
   // out mode.
   // If you want to know when the service is started, use
@@ -52,14 +52,20 @@ class COMPONENT_EXPORT(ASSISTANT_SERVICE) AssistantManagerService
   virtual void Start(const base::Optional<std::string>& access_token,
                      bool enable_hotword) = 0;
 
-  // Stop the assistant.
+  // Stop the Assistant.
   virtual void Stop() = 0;
 
   // Return the current state.
   virtual State GetState() const = 0;
 
-  // Set access token for assistant.
-  virtual void SetAccessToken(const std::string& access_token) = 0;
+  // Set access token for Assistant. Passing a nullopt will reconfigure
+  // Libassistant to run in signed-out mode, and passing a valid non-empty value
+  // will switch the mode back to normal.
+  virtual void SetAccessToken(
+      const base::Optional<std::string>& access_token) = 0;
+
+  // Enable/disable ambient mode for Assistant.
+  virtual void EnableAmbientMode(bool enabled) = 0;
 
   // Turn on / off all listening, including hotword and voice query.
   virtual void EnableListening(bool enable) = 0;

chromeos/services/assistant/assistant_manager_service_impl.cc

@@ -8,6 +8,7 @@
 #include <memory>
 #include <utility>
 
+#include "ash/public/cpp/ambient/ambient_mode_state.h"
 #include "ash/public/cpp/assistant/assistant_state_base.h"
 #include "base/barrier_closure.h"
 #include "base/bind.h"
@@ -26,6 +27,7 @@
 #include "chromeos/assistant/internal/proto/google3/assistant/api/client_input/warmer_welcome_input.pb.h"
 #include "chromeos/assistant/internal/proto/google3/assistant/api/client_op/device_args.pb.h"
 #include "chromeos/constants/chromeos_features.h"
+#include "chromeos/constants/chromeos_switches.h"
 #include "chromeos/dbus/util/version_loader.h"
 #include "chromeos/services/assistant/assistant_manager_service_delegate.h"
 #include "chromeos/services/assistant/constants.h"
@@ -143,6 +145,15 @@ CommunicationErrorType CommunicationErrorTypeFromLibassistantErrorCode(
   return CommunicationErrorType::Other;
 }
 
+std::vector<std::pair<std::string, std::string>> ReturnAuthTokensOrEmpty(
+    const base::Optional<std::string>& access_token) {
+  if (!access_token.has_value())
+    return {};
+
+  DCHECK(!access_token.value().empty());
+  return {std::pair<std::string, std::string>(kUserID, access_token.value())};
+}
+
 }  // namespace
 
 AssistantManagerServiceImpl::AssistantManagerServiceImpl(
@@ -151,8 +162,7 @@ AssistantManagerServiceImpl::AssistantManagerServiceImpl(
     std::unique_ptr<AssistantManagerServiceDelegate> delegate,
     std::unique_ptr<network::PendingSharedURLLoaderFactory>
         pending_url_loader_factory,
-    base::Optional<std::string> s3_server_uri_override,
-    bool is_signed_out_mode)
+    base::Optional<std::string> s3_server_uri_override)
     : client_(client),
       media_session_(std::make_unique<AssistantMediaSession>(client_, this)),
       action_module_(std::make_unique<action::CrosActionModule>(
@@ -165,7 +175,6 @@ AssistantManagerServiceImpl::AssistantManagerServiceImpl(
       context_(context),
       delegate_(std::move(delegate)),
       background_thread_("background thread"),
-      is_signed_out_mode_(is_signed_out_mode),
       libassistant_config_(CreateLibAssistantConfig(s3_server_uri_override)),
       weak_factory_(this) {
   background_thread_.Start();
@@ -182,10 +191,6 @@ AssistantManagerServiceImpl::AssistantManagerServiceImpl(
 }
 
 AssistantManagerServiceImpl::~AssistantManagerServiceImpl() {
-  auto* ambient_state = ash::AmbientModeState::Get();
-  if (ambient_state)
-    ambient_state->RemoveObserver(this);
-
   background_thread_.Stop();
 }
 
@@ -202,15 +207,12 @@ void AssistantManagerServiceImpl::Start(
 
   EnableHotword(enable_hotword);
 
+  // Check the AmbientModeState to keep us synced on |ambient_state|.
   if (chromeos::features::IsAmbientModeEnabled()) {
     auto* ambient_state = ash::AmbientModeState::Get();
     DCHECK(ambient_state);
 
-    // Update the support action list in action module when system enters/exits
-    // the Ambient Mode. Some actions such as open URL in the browser will be
-    // disabled in this mode.
-    action_module_->SetAmbientModeEnabled(ambient_state->enabled());
-    ambient_state->AddObserver(this);
+    EnableAmbientMode(ambient_state->enabled());
   }
 
   // LibAssistant creation will make file IO and sync wait. Post the creation to
@@ -229,12 +231,6 @@ void AssistantManagerServiceImpl::Stop() {
 
   SetStateAndInformObservers(State::STOPPED);
 
-  if (chromeos::features::IsAmbientModeEnabled()) {
-    auto* ambient_state = ash::AmbientModeState::Get();
-    DCHECK(ambient_state);
-    ambient_state->RemoveObserver(this);
-  }
-
   // When user disables the feature, we also deletes all data.
   if (!assistant_state()->settings_enabled().value() && assistant_manager_)
     assistant_manager_->ResetAllDataAndShutdown();
@@ -251,20 +247,28 @@ AssistantManagerService::State AssistantManagerServiceImpl::GetState() const {
 }
 
 void AssistantManagerServiceImpl::SetAccessToken(
-    const std::string& access_token) {
+    const base::Optional<std::string>& access_token) {
   if (!assistant_manager_)
     return;
 
-  DCHECK(!access_token.empty());
-
   VLOG(1) << "Set access token.";
   // Push the |access_token| we got as an argument into AssistantManager before
   // starting to ensure that all server requests will be authenticated once
   // it is started. |user_id| is used to pair a user to their |access_token|,
   // since we do not support multi-user in this example we can set it to a
-  // dummy value like "0".
-  assistant_manager_->SetAuthTokens(
-      {std::pair<std::string, std::string>(kUserID, access_token)});
+  // dummy value like "0". When |access_token| does not contain a value, we
+  // need to switch Libassistant to signed-out mode so that it can work with
+  // 0 auth token.
+  assistant_manager_->SetAuthTokens(ReturnAuthTokensOrEmpty(access_token));
+}
+
+void AssistantManagerServiceImpl::EnableAmbientMode(bool enabled) {
+  if (!assistant_manager_)
+    return;
+
+  // Update |action_module_| accordingly, as some actions, e.g. open URL
+  // in the browser, are not supported in ambient mode.
+  action_module_->SetAmbientModeEnabled(enabled);
 }
 
 void AssistantManagerServiceImpl::RegisterFallbackMediaHandler() {
@@ -1178,10 +1182,9 @@ void AssistantManagerServiceImpl::StartAssistantInternal(
         server_experiment_ids);
   }
 
-  if (!is_signed_out_mode_) {
-    new_assistant_manager_->SetAuthTokens(
-        {std::pair<std::string, std::string>(kUserID, access_token.value())});
-  }
+  // When |access_token| does not contain a value, we will start Libassistant
+  // in signed-out mode by calling SetAuthTokens() with an empty vector.
+  new_assistant_manager_->SetAuthTokens(ReturnAuthTokensOrEmpty(access_token));
   new_assistant_manager_->Start();
 }
 
@@ -1316,10 +1319,6 @@ void AssistantManagerServiceImpl::OnAndroidAppListRefreshed(
   display_connection_->OnAndroidAppListRefreshed(android_apps_info);
 }
 
-void AssistantManagerServiceImpl::OnAmbientModeEnabled(bool enabled) {
-  action_module_->SetAmbientModeEnabled(enabled);
-}
-
 void AssistantManagerServiceImpl::UpdateInternalOptions(
     assistant_client::AssistantManagerInternal* assistant_manager_internal) {
   // Build internal options
@@ -1331,7 +1330,11 @@ void AssistantManagerServiceImpl::UpdateInternalOptions(
   internal_options->SetClientControlEnabled(
       assistant::features::IsRoutinesEnabled());
 
-  if (is_signed_out_mode_) {
+  // TODO(meilinw): remove this logic and instead use the new config flag
+  // once we uprev.
+  if (chromeos::features::IsAmbientModeEnabled() ||
+      base::CommandLine::ForCurrentProcess()->HasSwitch(
+          chromeos::switches::kDisableGaiaServices)) {
     internal_options->SetUserCredentialMode(
         assistant_client::InternalOptions::UserCredentialMode::SIGNED_OUT);
   }

chromeos/services/assistant/assistant_manager_service_impl.h

@@ -10,7 +10,6 @@
 #include <string>
 #include <vector>
 
-#include "ash/public/cpp/ambient/ambient_mode_state.h"
 #include "ash/public/mojom/assistant_controller.mojom.h"
 #include "base/memory/scoped_refptr.h"
 #include "base/optional.h"
@@ -96,8 +95,7 @@ class COMPONENT_EXPORT(ASSISTANT_SERVICE) AssistantManagerServiceImpl
       public assistant_client::DeviceStateListener,
       public assistant_client::MediaManager::Listener,
       public media_session::mojom::MediaControllerObserver,
-      public mojom::AppListEventSubscriber,
-      public ash::AmbientModeStateObserver {
+      public mojom::AppListEventSubscriber {
  public:
   // |service| owns this class and must outlive this class.
   AssistantManagerServiceImpl(
@@ -106,8 +104,7 @@ class COMPONENT_EXPORT(ASSISTANT_SERVICE) AssistantManagerServiceImpl
       std::unique_ptr<AssistantManagerServiceDelegate> delegate,
       std::unique_ptr<network::PendingSharedURLLoaderFactory>
           pending_url_loader_factory,
-      base::Optional<std::string> s3_server_uri_override,
-      bool is_signed_out_mode);
+      base::Optional<std::string> s3_server_uri_override);
 
   ~AssistantManagerServiceImpl() override;
 
@@ -116,7 +113,8 @@ class COMPONENT_EXPORT(ASSISTANT_SERVICE) AssistantManagerServiceImpl
              bool enable_hotword) override;
   void Stop() override;
   State GetState() const override;
-  void SetAccessToken(const std::string& access_token) override;
+  void SetAccessToken(const base::Optional<std::string>& access_token) override;
+  void EnableAmbientMode(bool enabled) override;
   void EnableListening(bool enable) override;
   void EnableHotword(bool enable) override;
   void SetArcPlayStoreEnabled(bool enable) override;
@@ -204,9 +202,6 @@ class COMPONENT_EXPORT(ASSISTANT_SERVICE) AssistantManagerServiceImpl
   void OnAndroidAppListRefreshed(
       std::vector<mojom::AndroidAppInfoPtr> apps_info) override;
 
-  // ash::AmbientModeStateObserver overrides:
-  void OnAmbientModeEnabled(bool enabled) override;
-
   void UpdateInternalOptions(
       assistant_client::AssistantManagerInternal* assistant_manager_internal);
 
@@ -367,7 +362,6 @@ class COMPONENT_EXPORT(ASSISTANT_SERVICE) AssistantManagerServiceImpl
   std::string receive_url_response_;
 
   bool is_first_client_discourse_context_query_ = true;
-  bool is_signed_out_mode_;
 
   mojo::Receiver<media_session::mojom::MediaControllerObserver>
       media_controller_observer_receiver_{this};

chromeos/services/assistant/assistant_manager_service_impl_unittest.cc

@@ -197,8 +197,7 @@ class AssistantManagerServiceImplTest : public testing::Test {
 
     assistant_manager_service_ = std::make_unique<AssistantManagerServiceImpl>(
         &assistant_client_, service_context_.get(), std::move(delegate),
-        shared_url_loader_factory_->Clone(), s3_server_uri_override,
-        /*is_signed_out_mode=*/false);
+        shared_url_loader_factory_->Clone(), s3_server_uri_override);
   }
 
   void TearDown() override {

chromeos/services/assistant/fake_assistant_manager_service_impl.cc

@@ -21,6 +21,7 @@ void FakeAssistantManagerServiceImpl::Start(
     const base::Optional<std::string>& access_token,
     bool enable_hotword) {
   SetStateAndInformObservers(State::STARTING);
+  access_token_ = access_token;
 }
 
 void FakeAssistantManagerServiceImpl::Stop() {
@@ -28,12 +29,16 @@ void FakeAssistantManagerServiceImpl::Stop() {
 }
 
 void FakeAssistantManagerServiceImpl::SetAccessToken(
-    const std::string& access_token) {}
+    const base::Optional<std::string>& access_token) {
+  access_token_ = access_token;
+}
 
 void FakeAssistantManagerServiceImpl::EnableListening(bool enable) {}
 
 void FakeAssistantManagerServiceImpl::EnableHotword(bool enable) {}
 
+void FakeAssistantManagerServiceImpl::EnableAmbientMode(bool enabled) {}
+
 void FakeAssistantManagerServiceImpl::SetArcPlayStoreEnabled(bool enabled) {}
 
 AssistantManagerService::State FakeAssistantManagerServiceImpl::GetState()

chromeos/services/assistant/fake_assistant_manager_service_impl.h

@@ -31,9 +31,10 @@ class COMPONENT_EXPORT(ASSISTANT_SERVICE) FakeAssistantManagerServiceImpl
   void Start(const base::Optional<std::string>& access_token,
              bool enable_hotword) override;
   void Stop() override;
-  void SetAccessToken(const std::string& access_token) override;
+  void SetAccessToken(const base::Optional<std::string>& access_token) override;
   void EnableListening(bool enable) override;
   void EnableHotword(bool enable) override;
+  void EnableAmbientMode(bool enabled) override;
   void SetArcPlayStoreEnabled(bool enabled) override;
   State GetState() const override;
   AssistantSettingsManager* GetAssistantSettingsManager() override;
@@ -74,12 +75,16 @@ class COMPONENT_EXPORT(ASSISTANT_SERVICE) FakeAssistantManagerServiceImpl
   // |AssistantStateObserver| of the change.
   void SetStateAndInformObservers(State new_state);
 
+  // Return the |access_token| that was passed to |SetAccessToken|.
+  base::Optional<std::string> access_token() { return access_token_; }
+
  private:
   // Send out a |AssistantStateObserver::OnStateChange(state)| event if we are
   // transitioning from a prior state to a later state.
   void MaybeSendStateChange(State state, State old_state, State target_state);
 
   State state_ = State::STOPPED;
+  base::Optional<std::string> access_token_;
   FakeAssistantSettingsManagerImpl assistant_settings_manager_;
   base::ObserverList<StateObserver> state_observers_;
 

chromeos/services/assistant/service.cc

@@ -20,6 +20,7 @@
 #include "build/buildflag.h"
 #include "chromeos/assistant/buildflags.h"
 #include "chromeos/audio/cras_audio_handler.h"
+#include "chromeos/constants/chromeos_features.h"
 #include "chromeos/constants/chromeos_switches.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/power_manager/power_supply_properties.pb.h"
@@ -90,6 +91,22 @@ base::Optional<std::string> GetS3ServerUriOverride() {
 }
 #endif
 
+// In the signed-out mode, we are going to run Assistant service without
+// using user's signed in account information.
+bool IsSignedOutMode() {
+  // We will switch the Libassitsant mode to signed-out/signed-in when user
+  // enters/exits the ambient mode.
+  const bool entered_ambient_mode =
+      chromeos::features::IsAmbientModeEnabled() &&
+      ash::AmbientModeState::Get()->enabled();
+
+  // Note that we shouldn't toggle the flag to true when exiting ambient
+  // mode if we have been using fake gaia login, e.g. in the Tast test.
+  return entered_ambient_mode ||
+         base::CommandLine::ForCurrentProcess()->HasSwitch(
+             chromeos::switches::kDisableGaiaServices);
+}
+
 }  // namespace
 
 class Service::Context : public ServiceContext {
@@ -164,6 +181,11 @@ Service::Service(mojo::PendingReceiver<mojom::AssistantService> receiver,
 
 Service::~Service() {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  // Add null check for |AmbientModeState| in case that |Service| is released
+  // after ash has gone.
+  if (chromeos::features::IsAmbientModeEnabled() &&
+      ash::AmbientModeState::Get())
+    ash::AmbientModeState::Get()->RemoveObserver(this);
   assistant_state_.RemoveObserver(this);
   auto* const session_controller = ash::SessionController::Get();
   if (observing_ash_session_ && session_controller) {
@@ -213,12 +235,8 @@ void Service::Init(mojo::PendingRemote<mojom::Client> client,
 
   DCHECK(!assistant_manager_service_);
 
-  // Don't fetch token for test.
-  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
-          chromeos::switches::kDisableGaiaServices)) {
-    is_signed_out_mode_ = true;
-    return;
-  }
+  if (chromeos::features::IsAmbientModeEnabled())
+    ash::AmbientModeState::Get()->AddObserver(this);
 
   RequestAccessToken();
 }
@@ -338,18 +356,34 @@ void Service::OnStateChanged(AssistantManagerService::State new_state) {
   UpdateListeningState();
 }
 
+void Service::OnAmbientModeEnabled(bool enabled) {
+  if (IsSignedOutMode()) {
+    UpdateAssistantManagerState();
+  } else {
+    // Refresh the access_token before we switch back to signed-in mode in case
+    // that we don't have any auth_token cached before.
+    RequestAccessToken();
+  }
+}
+
 void Service::UpdateAssistantManagerState() {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   if (!assistant_state_.hotword_enabled().has_value() ||
       !assistant_state_.settings_enabled().has_value() ||
       !assistant_state_.locale().has_value() ||
-      (!access_token_.has_value() && !is_signed_out_mode_) ||
+      (!access_token_.has_value() && !IsSignedOutMode()) ||
       !assistant_state_.arc_play_store_enabled().has_value()) {
     // Assistant state has not finished initialization, let's wait.
     return;
   }
 
+  if (IsSignedOutMode()) {
+    // Clear |access_token_| in signed-out mode to keep it synced with what we
+    // will pass to the |assistant_manager_service_|.
+    access_token_ = base::nullopt;
+  }
+
   if (!assistant_manager_service_)
     CreateAssistantManagerService();
 
@@ -357,9 +391,7 @@ void Service::UpdateAssistantManagerState() {
   switch (state) {
     case AssistantManagerService::State::STOPPED:
       if (assistant_state_.settings_enabled().value()) {
-        assistant_manager_service_->Start(
-            is_signed_out_mode_ ? base::nullopt : access_token_,
-            ShouldEnableHotword());
+        assistant_manager_service_->Start(access_token_, ShouldEnableHotword());
         DVLOG(1) << "Request Assistant start";
       }
       break;
@@ -384,8 +416,11 @@ void Service::UpdateAssistantManagerState() {
       break;
     case AssistantManagerService::State::RUNNING:
       if (assistant_state_.settings_enabled().value()) {
-        if (!is_signed_out_mode_)
-          assistant_manager_service_->SetAccessToken(access_token_.value());
+        assistant_manager_service_->SetAccessToken(access_token_);
+        if (chromeos::features::IsAmbientModeEnabled()) {
+          assistant_manager_service_->EnableAmbientMode(
+              ash::AmbientModeState::Get()->enabled());
+        }
         assistant_manager_service_->EnableHotword(ShouldEnableHotword());
         assistant_manager_service_->SetArcPlayStoreEnabled(
             assistant_state_.arc_play_store_enabled().value());
@@ -407,8 +442,8 @@ identity::mojom::IdentityAccessor* Service::GetIdentityAccessor() {
 void Service::RequestAccessToken() {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
-  // Bypass access token fetching under signed out mode.
-  if (is_signed_out_mode_)
+  // Bypass access token fetching when service is running in signed-out mode.
+  if (IsSignedOutMode())
     return;
 
   VLOG(1) << "Start requesting access token.";
@@ -504,8 +539,7 @@ Service::CreateAndReturnAssistantManagerService() {
   DCHECK(pending_url_loader_factory_);
   return std::make_unique<AssistantManagerServiceImpl>(
       client_.get(), context(), std::move(delegate),
-      std::move(pending_url_loader_factory_), GetS3ServerUriOverride(),
-      is_signed_out_mode_);
+      std::move(pending_url_loader_factory_), GetS3ServerUriOverride());
 #else
   return std::make_unique<FakeAssistantManagerServiceImpl>();
 #endif

chromeos/services/assistant/service.h

@@ -8,6 +8,7 @@
 #include <memory>
 #include <string>
 
+#include "ash/public/cpp/ambient/ambient_mode_state.h"
 #include "ash/public/cpp/session/session_activation_observer.h"
 #include "ash/public/mojom/assistant_controller.mojom.h"
 #include "base/callback.h"
@@ -64,7 +65,8 @@ class COMPONENT_EXPORT(ASSISTANT_SERVICE) Service
       public ash::SessionActivationObserver,
       public ash::AssistantStateObserver,
       public AssistantManagerService::CommunicationErrorObserver,
-      public AssistantManagerService::StateObserver {
+      public AssistantManagerService::StateObserver,
+      public ash::AmbientModeStateObserver {
  public:
   Service(mojo::PendingReceiver<mojom::AssistantService> receiver,
           std::unique_ptr<network::PendingSharedURLLoaderFactory>
@@ -131,6 +133,9 @@ class COMPONENT_EXPORT(ASSISTANT_SERVICE) Service
   // AssistantManagerService::StateObserver overrides:
   void OnStateChanged(AssistantManagerService::State new_state) override;
 
+  // ash::AmbientModeStateObserver overrides:
+  void OnAmbientModeEnabled(bool enabled) override;
+
   void UpdateAssistantManagerState();
 
   identity::mojom::IdentityAccessor* GetIdentityAccessor();
@@ -191,9 +196,6 @@ class COMPONENT_EXPORT(ASSISTANT_SERVICE) Service
   bool locked_ = false;
   // Whether the power source is connected.
   bool power_source_connected_ = false;
-  // In the signed-out mode, we are going to run Assistant service without
-  // using user's signed in account information.
-  bool is_signed_out_mode_ = false;
 
   // The value passed into |SetAssistantManagerServiceForTesting|.
   // Will be moved into |assistant_manager_service_| when the service is

chromeos/services/assistant/service_unittest.cc

@@ -13,12 +13,14 @@
 #include "base/macros.h"
 #include "base/memory/scoped_refptr.h"
 #include "base/run_loop.h"
+#include "base/test/scoped_feature_list.h"
 #include "base/test/task_environment.h"
 #include "base/test/test_mock_time_task_runner.h"
 #include "base/time/tick_clock.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "chromeos/audio/cras_audio_handler.h"
+#include "chromeos/constants/chromeos_features.h"
 #include "chromeos/dbus/power/fake_power_manager_client.h"
 #include "chromeos/services/assistant/assistant_state_proxy.h"
 #include "chromeos/services/assistant/fake_assistant_manager_service_impl.h"
@@ -167,6 +169,9 @@ class AssistantServiceTest : public testing::Test {
   ~AssistantServiceTest() override = default;
 
   void SetUp() override {
+    scoped_feature_list_.InitAndEnableFeature(
+        chromeos::features::kAmbientModeFeature);
+
     chromeos::CrasAudioHandler::InitializeForTesting();
 
     PowerManagerClient::InitializeFake();
@@ -229,8 +234,11 @@ class AssistantServiceTest : public testing::Test {
     return mock_task_runner_.get();
   }
 
+  ash::AmbientModeState* ambient_mode_state() { return &ambient_mode_state_; }
+
  private:
   base::test::TaskEnvironment task_environment_;
+  base::test::ScopedFeatureList scoped_feature_list_;
 
   std::unique_ptr<Service> service_;
   mojo::Remote<mojom::AssistantService> remote_service_;
@@ -248,6 +256,8 @@ class AssistantServiceTest : public testing::Test {
   scoped_refptr<base::TestMockTimeTaskRunner> mock_task_runner_;
   std::unique_ptr<base::OneShotTimer> mock_timer_;
 
+  ash::AmbientModeState ambient_mode_state_;
+
   DISALLOW_COPY_AND_ASSIGN(AssistantServiceTest);
 };
 
@@ -368,5 +378,23 @@ TEST_F(AssistantServiceTest, ShouldSetClientStatusToNotReadyWhenStopped) {
   EXPECT_EQ(client()->status(), ash::mojom::AssistantState::NOT_READY);
 }
 
+TEST_F(AssistantServiceTest,
+       ShouldResetAccessTokenWhenAmbientModeStateChanged) {
+  assistant_manager()->FinishStart();
+  EXPECT_EQ(assistant_manager()->GetState(),
+            AssistantManagerService::State::RUNNING);
+  ASSERT_TRUE(assistant_manager()->access_token().has_value());
+  ASSERT_EQ(assistant_manager()->access_token().value(), "fake access token");
+
+  ambient_mode_state()->SetAmbientModeEnabled(true);
+  base::RunLoop().RunUntilIdle();
+  ASSERT_FALSE(assistant_manager()->access_token().has_value());
+
+  ambient_mode_state()->SetAmbientModeEnabled(false);
+  base::RunLoop().RunUntilIdle();
+  ASSERT_TRUE(assistant_manager()->access_token().has_value());
+  ASSERT_EQ(assistant_manager()->access_token().value(), "fake access token");
+}
+
 }  // namespace assistant
 }  // namespace chromeos