assistant: add assistant entry in launcher search

Append a link to the assistant in launcher results when no
tiles are shown. Gated by feature "EnabledEmbeddedAssistantUI".
https://screenshot.googleplex.com/9H5Ds7TjUPmgoxi.png

BUG=1103703

Cq-Include-Trybots: luci.chrome.try:linux-chromeos-chrome
Change-Id: I28dc5c06a85863d0f78eb1da26b214c774008041
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2388001Reviewed-by: Tony Yeoman <tby@chromium.org>
Reviewed-by: Xiaohui Chen <xiaohuic@chromium.org>
Reviewed-by: Tao Wu <wutao@chromium.org>
Reviewed-by: Xiyuan Xia <xiyuan@chromium.org>
Commit-Queue: Jeffrey Young <cowmoo@chromium.org>
Cr-Commit-Position: refs/heads/master@{#808926}

ash/app_list/app_list_controller_impl.cc

@@ -1177,30 +1177,9 @@ void AppListControllerImpl::OpenSearchResult(const std::string& result_id,
     }
   }
 
-  if (presenter_.IsVisibleDeprecated() && result->is_omnibox_search() &&
-      IsAssistantAllowedAndEnabled() &&
-      app_list_features::IsAssistantSearchEnabled()) {
-    // Record the assistant result. Other types of results are recorded in
-    // |client_| where there is richer data on SearchResultType.
-    DCHECK_EQ(AppListLaunchedFrom::kLaunchedFromSearchBox, launched_from)
-        << "Only log search results which are represented to the user as "
-           "search results (ie. search results in the search result page) not "
-           "chips.";
-    RecordSearchResultOpenTypeHistogram(launched_from, ASSISTANT_OMNIBOX_RESULT,
-                                        IsTabletMode());
-    if (!GetLastQueryLength()) {
-      RecordZeroStateSuggestionOpenTypeHistogram(ASSISTANT_OMNIBOX_RESULT);
-    }
-    AssistantUiController::Get()->ShowUi(
-        AssistantEntryPoint::kLauncherSearchResult);
-    AssistantController::Get()->OpenUrl(
-        assistant::util::CreateAssistantQueryDeepLink(
-            base::UTF16ToUTF8(result->title())));
-  } else {
-    if (client_)
-      client_->OpenSearchResult(result_id, event_flags, launched_from,
-                                launch_type, suggestion_index,
-                                launch_as_default);
+  if (client_) {
+    client_->OpenSearchResult(result_id, event_flags, launched_from,
+                              launch_type, suggestion_index, launch_as_default);
   }
 
   ResetHomeLauncherIfShown();

ash/app_list/views/search_result_list_view.h

@@ -71,6 +71,12 @@ class APP_LIST_EXPORT SearchResultListView : public SearchResultContainerView {
   // after a period of time.
   void LogImpressions();
 
+  // Returns search results specific to Assistant if any are available.
+  std::vector<SearchResult*> GetAssistantResults();
+
+  // Returns regular search results with Assistant search results appended.
+  std::vector<SearchResult*> GetSearchResults();
+
   AppListMainView* main_view_;          // Owned by views hierarchy.
   AppListViewDelegate* view_delegate_;  // Not owned.
 

ash/app_list/views/search_result_list_view_unittest.cc

@@ -57,10 +57,35 @@ class SearchResultListViewTest : public views::test::WidgetTest {
     return view_->GetResultViewAt(index);
   }
 
+  std::vector<SearchResultView*> GetAssistantResultViews() const {
+    std::vector<SearchResultView*> results;
+    for (auto* view : view_->search_result_views_) {
+      auto* result = view->result();
+      if (result &&
+          result->result_type() == AppListSearchResultType::kAssistantText)
+        results.push_back(view);
+    }
+    return results;
+  }
+
   SearchModel::SearchResults* GetResults() {
     return view_delegate_.GetSearchModel()->results();
   }
 
+  void AddAssistantSearchResult() {
+    SearchModel::SearchResults* results = GetResults();
+
+    std::unique_ptr<TestSearchResult> assistant_result =
+        std::make_unique<TestSearchResult>();
+    assistant_result->set_result_type(
+        ash::AppListSearchResultType::kAssistantText);
+    assistant_result->set_display_type(ash::SearchResultDisplayType::kList);
+    assistant_result->set_title(base::UTF8ToUTF16("assistant result"));
+    results->Add(std::move(assistant_result));
+
+    RunPendingMessages();
+  }
+
   void SetUpSearchResults() {
     SearchModel::SearchResults* results = GetResults();
     for (int i = 0; i < kDefaultSearchItems; ++i) {
@@ -153,5 +178,31 @@ TEST_F(SearchResultListViewTest, ModelObservers) {
   ExpectConsistent();
 }
 
+TEST_F(SearchResultListViewTest, HidesAssistantResultWhenTilesVisible) {
+  SetUpSearchResults();
+
+  // No assistant results available.
+  EXPECT_TRUE(GetAssistantResultViews().empty());
+
+  AddAssistantSearchResult();
+
+  // Assistant result should be set and visible.
+  for (const auto* view : GetAssistantResultViews()) {
+    EXPECT_TRUE(view->GetVisible());
+    EXPECT_EQ(view->result()->title(), base::UTF8ToUTF16("assistant result"));
+  }
+
+  // Add a tile result
+  std::unique_ptr<TestSearchResult> tile_result =
+      std::make_unique<TestSearchResult>();
+  tile_result->set_display_type(ash::SearchResultDisplayType::kTile);
+  GetResults()->Add(std::move(tile_result));
+
+  RunPendingMessages();
+
+  // Assistant result should be gone.
+  EXPECT_TRUE(GetAssistantResultViews().empty());
+}
+
 }  // namespace test
 }  // namespace ash

ash/public/cpp/app_list/app_list_config.h

@@ -187,6 +187,10 @@ class ASH_PUBLIC_EXPORT AppListConfig {
     return max_search_result_list_items_;
   }
 
+  size_t max_assistant_search_result_list_items() const {
+    return max_assistant_search_result_list_items_;
+  }
+
   double privacy_container_score() const { return privacy_container_score_; }
   double app_tiles_container_score() const {
     return app_tiles_container_score_;
@@ -510,6 +514,10 @@ class ASH_PUBLIC_EXPORT AppListConfig {
   // Max number of search result list items in the launcher suggestion window.
   const size_t max_search_result_list_items_ = 5;
 
+  // Max number of Assistant search result list items in the launcher suggestion
+  // window. Appears in the list after normal search results.
+  const size_t max_assistant_search_result_list_items_ = 1;
+
   // Scores for the containers within the search box view. These are displayed
   // in high-to-low order.
   // The privacy container is not always visible, but when available it should

ash/public/cpp/app_list/app_list_types.h

@@ -151,6 +151,7 @@ enum class AppListSearchResultType {
   kAssistantChip,          // Assistant results in suggestion chips.
   kOsSettings,             // OS settings results.
   kInternalPrivacyInfo,    // Result used internally by privacy notices.
+  kAssistantText,          // Assistant text results.
   // Add new values here.
 };
 

ash/public/cpp/assistant/test_support/BUILD.gn

@@ -4,6 +4,8 @@ static_library("test_support") {
   sources = [
     "mock_assistant_controller.cc",
     "mock_assistant_controller.h",
+    "mock_assistant_state.cc",
+    "mock_assistant_state.h",
   ]
 
   deps = [

ash/public/cpp/assistant/test_support/mock_assistant_state.cc

+// Copyright 2020 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 "ash/public/cpp/assistant/test_support/mock_assistant_state.h"
+
+namespace ash {
+
+MockAssistantState::MockAssistantState() {
+  allowed_state_ = chromeos::assistant::AssistantAllowedState::ALLOWED;
+  settings_enabled_ = true;
+}
+
+MockAssistantState::~MockAssistantState() = default;
+
+void MockAssistantState::SetAllowedState(
+    chromeos::assistant::AssistantAllowedState allowed_state) {
+  if (allowed_state_ != allowed_state) {
+    allowed_state_ = allowed_state;
+    for (auto& observer : observers_)
+      observer.OnAssistantFeatureAllowedChanged(allowed_state_.value());
+  }
+}
+
+void MockAssistantState::SetSettingsEnabled(bool enabled) {
+  if (settings_enabled_ != enabled) {
+    settings_enabled_ = enabled;
+    for (auto& observer : observers_)
+      observer.OnAssistantSettingsEnabled(settings_enabled_.value());
+  }
+}
+
+}  // namespace ash

ash/public/cpp/assistant/test_support/mock_assistant_state.h

+// Copyright 2020 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.
+
+#ifndef ASH_PUBLIC_CPP_ASSISTANT_TEST_SUPPORT_MOCK_ASSISTANT_STATE_H_
+#define ASH_PUBLIC_CPP_ASSISTANT_TEST_SUPPORT_MOCK_ASSISTANT_STATE_H_
+
+#include "ash/public/cpp/assistant/assistant_state.h"
+
+namespace ash {
+
+class MockAssistantState : public ash::AssistantState {
+ public:
+  MockAssistantState();
+  MockAssistantState(const MockAssistantState&) = delete;
+  MockAssistantState& operator=(const MockAssistantState&) = delete;
+  ~MockAssistantState() override;
+
+  void SetAllowedState(
+      chromeos::assistant::AssistantAllowedState allowed_state);
+
+  void SetSettingsEnabled(bool enabled);
+};
+
+}  // namespace ash
+
+#endif  // ASH_PUBLIC_CPP_ASSISTANT_TEST_SUPPORT_MOCK_ASSISTANT_STATE_H_

chrome/browser/ui/BUILD.gn

@@ -1719,6 +1719,8 @@ static_library("ui") {
       "app_list/search/arc/arc_playstore_search_result.h",
       "app_list/search/assistant_search_provider.cc",
       "app_list/search/assistant_search_provider.h",
+      "app_list/search/assistant_text_search_provider.cc",
+      "app_list/search/assistant_text_search_provider.h",
       "app_list/search/chrome_search_result.cc",
       "app_list/search/chrome_search_result.h",
       "app_list/search/common/url_icon_source.cc",

chrome/browser/ui/app_list/search/DEPS

@@ -2,4 +2,5 @@ include_rules = [
   "+ash/assistant/model",
   "+ash/assistant/util",
   "+ash/public/cpp/vector_icons",
+  "+ash/strings/grit",
 ]

chrome/browser/ui/app_list/search/assistant_search_provider_unittest.cc

@@ -13,6 +13,7 @@
 #include "ash/public/cpp/assistant/assistant_state.h"
 #include "ash/public/cpp/assistant/controller/assistant_suggestions_controller.h"
 #include "ash/public/cpp/assistant/test_support/mock_assistant_controller.h"
+#include "ash/public/cpp/assistant/test_support/mock_assistant_state.h"
 #include "ash/public/cpp/vector_icons/vector_icons.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
@@ -111,36 +112,6 @@ class ConversationStarterBuilder {
   GURL action_url_;
 };
 
-// TestAssistantState ----------------------------------------------------------
-
-class TestAssistantState : public ash::AssistantState {
- public:
-  TestAssistantState() {
-    allowed_state_ = chromeos::assistant::AssistantAllowedState::ALLOWED;
-    settings_enabled_ = true;
-  }
-
-  TestAssistantState(const TestAssistantState&) = delete;
-  TestAssistantState& operator=(const TestAssistantState&) = delete;
-  ~TestAssistantState() override = default;
-
-  void SetAllowedState(AssistantAllowedState allowed_state) {
-    if (allowed_state_ != allowed_state) {
-      allowed_state_ = allowed_state;
-      for (auto& observer : observers_)
-        observer.OnAssistantFeatureAllowedChanged(allowed_state_.value());
-    }
-  }
-
-  void SetSettingsEnabled(bool enabled) {
-    if (settings_enabled_ != enabled) {
-      settings_enabled_ = enabled;
-      for (auto& observer : observers_)
-        observer.OnAssistantSettingsEnabled(settings_enabled_.value());
-    }
-  }
-};
-
 // TestAssistantSuggestionsController ------------------------------------------
 
 class TestAssistantSuggestionsController
@@ -193,7 +164,7 @@ class AssistantSearchProviderTest : public AppListTestBase {
 
   AssistantSearchProvider& search_provider() { return search_provider_; }
 
-  TestAssistantState& assistant_state() { return assistant_state_; }
+  ash::MockAssistantState& assistant_state() { return assistant_state_; }
 
   NiceMock<ash::MockAssistantController>& assistant_controller() {
     return assistant_controller_;
@@ -204,7 +175,7 @@ class AssistantSearchProviderTest : public AppListTestBase {
   }
 
  private:
-  TestAssistantState assistant_state_;
+  ash::MockAssistantState assistant_state_;
   NiceMock<ash::MockAssistantController> assistant_controller_;
   TestAssistantSuggestionsController suggestions_controller_;
   AssistantSearchProvider search_provider_;

chrome/browser/ui/app_list/search/assistant_text_search_provider.cc

+// Copyright 2020 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 "chrome/browser/ui/app_list/search/assistant_text_search_provider.h"
+
+#include <memory>
+#include <vector>
+
+#include "ash/assistant/util/deep_link_util.h"
+#include "ash/public/cpp/app_list/app_list_config.h"
+#include "ash/public/cpp/app_list/app_list_controller.h"
+#include "ash/public/cpp/app_list/app_list_metrics.h"
+#include "ash/public/cpp/assistant/controller/assistant_controller.h"
+#include "ash/public/cpp/assistant/controller/assistant_suggestions_controller.h"
+#include "ash/public/cpp/vector_icons/vector_icons.h"
+#include "ash/strings/grit/ash_strings.h"
+#include "base/strings/string16.h"
+#include "base/strings/utf_string_conversions.h"
+#include "chrome/browser/ui/app_list/search/chrome_search_result.h"
+#include "chromeos/services/assistant/public/cpp/assistant_service.h"
+#include "ui/base/l10n/l10n_util.h"
+#include "ui/gfx/color_palette.h"
+#include "ui/gfx/paint_vector_icon.h"
+
+namespace app_list {
+
+namespace {
+
+using chromeos::assistant::AssistantAllowedState;
+
+constexpr char kIdPrefix[] = "googleassistant_text://";
+
+// Helpers ---------------------------------------------------------------------
+
+// Returns if the Assistant omnibox search provider is allowed to contribute
+// results.
+bool AreResultsAllowed() {
+  ash::AssistantState* assistant_state = ash::AssistantState::Get();
+  return assistant_state->allowed_state() == AssistantAllowedState::ALLOWED &&
+         assistant_state->settings_enabled() == true;
+}
+
+// AssistantTextSearchResult
+// -------------------------------------------------------
+
+class AssistantTextSearchResult : public ChromeSearchResult {
+ public:
+  explicit AssistantTextSearchResult(const base::string16& text)
+      : action_url_(ash::assistant::util::CreateAssistantQueryDeepLink(
+            base::UTF16ToUTF8(text))) {
+    set_id(kIdPrefix + base::UTF16ToUTF8(text));
+    SetDisplayType(ash::SearchResultDisplayType::kList);
+    SetResultType(ash::AppListSearchResultType::kAssistantText);
+    SetMetricsType(ash::SearchResultType::ASSISTANT_OMNIBOX_RESULT);
+    SetTitle(text);
+    SetAccessibleName(l10n_util::GetStringFUTF16(
+        IDS_ASH_ASSISTANT_QUERY_ACCESSIBILITY_ANNOUNCEMENT, text));
+    SetIcon(gfx::CreateVectorIcon(
+        ash::kAssistantIcon,
+        ash::AppListConfig::instance().search_list_icon_dimension(),
+        gfx::kPlaceholderColor));
+
+    set_dismiss_view_on_open(false);
+  }
+
+  AssistantTextSearchResult(const AssistantTextSearchResult&) = delete;
+  AssistantTextSearchResult& operator=(const AssistantTextSearchResult&) =
+      delete;
+  ~AssistantTextSearchResult() override = default;
+
+ private:
+  void Open(int event_flags) override {
+    // Opening of |action_url_| is delegated to the Assistant controller as only
+    // the Assistant controller knows how to handle Assistant deep links.
+    ash::AssistantController::Get()->OpenUrl(action_url_);
+  }
+
+  const GURL action_url_;
+};
+
+}  // namespace
+
+// AssistantTextSearchProvider -------------------------------------------------
+
+AssistantTextSearchProvider::AssistantTextSearchProvider() {
+  UpdateResults();
+
+  // Bind observers.
+  assistant_controller_observer_.Add(ash::AssistantController::Get());
+  assistant_state_observer_.Add(ash::AssistantState::Get());
+}
+
+AssistantTextSearchProvider::~AssistantTextSearchProvider() = default;
+
+ash::AppListSearchResultType AssistantTextSearchProvider::ResultType() {
+  return ash::AppListSearchResultType::kAssistantText;
+}
+
+void AssistantTextSearchProvider::Start(const base::string16& query) {
+  query_ = query;
+  UpdateResults();
+}
+
+void AssistantTextSearchProvider::OnAssistantControllerDestroying() {
+  assistant_state_observer_.Remove(ash::AssistantState::Get());
+  assistant_controller_observer_.Remove(ash::AssistantController::Get());
+}
+
+void AssistantTextSearchProvider::OnAssistantFeatureAllowedChanged(
+    chromeos::assistant::AssistantAllowedState allowed_state) {
+  UpdateResults();
+}
+
+void AssistantTextSearchProvider::OnAssistantSettingsEnabled(bool enabled) {
+  UpdateResults();
+}
+
+void AssistantTextSearchProvider::UpdateResults() {
+  if (!AreResultsAllowed() || query_.empty()) {
+    ClearResults();
+    return;
+  }
+  SearchProvider::Results results;
+  results.push_back(std::make_unique<AssistantTextSearchResult>(query_));
+  SwapResults(&results);
+}
+
+}  // namespace app_list

chrome/browser/ui/app_list/search/assistant_text_search_provider.h

+// Copyright 2020 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.
+
+#ifndef CHROME_BROWSER_UI_APP_LIST_SEARCH_ASSISTANT_TEXT_SEARCH_PROVIDER_H_
+#define CHROME_BROWSER_UI_APP_LIST_SEARCH_ASSISTANT_TEXT_SEARCH_PROVIDER_H_
+
+#include "ash/public/cpp/assistant/assistant_state.h"
+#include "ash/public/cpp/assistant/controller/assistant_controller.h"
+#include "ash/public/cpp/assistant/controller/assistant_controller_observer.h"
+#include "base/scoped_observer.h"
+#include "chrome/browser/ui/app_list/search/search_provider.h"
+
+namespace app_list {
+
+// A search provider implementation serving results from Assistant.
+// This is currently only used to provide a single search result that runs an
+// Assistant query of the search text. This is displayed when
+// kEnableAssistantSearch feature is enabled. This search result does not go
+// through normal ranking procedures, but is instead appended to an existing
+// list of search results.
+class AssistantTextSearchProvider : public SearchProvider,
+                                    public ash::AssistantControllerObserver,
+                                    public ash::AssistantStateObserver {
+ public:
+  AssistantTextSearchProvider();
+  AssistantTextSearchProvider(const AssistantTextSearchProvider&) = delete;
+  AssistantTextSearchProvider& operator=(const AssistantTextSearchProvider&) =
+      delete;
+  ~AssistantTextSearchProvider() override;
+
+  // SearchProvider:
+  void Start(const base::string16& query) override;
+
+ private:
+  // SearchProvider:
+  ash::AppListSearchResultType ResultType() override;
+
+  // ash::AssistantControllerObserver:
+  void OnAssistantControllerDestroying() override;
+
+  // ash::AssistantStateObserver:
+  void OnAssistantFeatureAllowedChanged(
+      chromeos::assistant::AssistantAllowedState allowed_state) override;
+  void OnAssistantSettingsEnabled(bool enabled) override;
+
+  // Invoke to update results based on current state.
+  void UpdateResults();
+
+  base::string16 query_;
+
+  ScopedObserver<ash::AssistantController, ash::AssistantControllerObserver>
+      assistant_controller_observer_{this};
+
+  ScopedObserver<ash::AssistantStateBase, ash::AssistantStateObserver>
+      assistant_state_observer_{this};
+};
+
+}  // namespace app_list
+
+#endif  // CHROME_BROWSER_UI_APP_LIST_SEARCH_ASSISTANT_TEXT_SEARCH_PROVIDER_H_

chrome/browser/ui/app_list/search/assistant_text_search_provider_unittest.cc

+// Copyright 2020 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 "chrome/browser/ui/app_list/search/assistant_text_search_provider.h"
+
+#include "ash/public/cpp/assistant/test_support/mock_assistant_controller.h"
+#include "ash/public/cpp/assistant/test_support/mock_assistant_state.h"
+#include "base/strings/string16.h"
+#include "base/strings/utf_string_conversions.h"
+#include "chrome/browser/ui/app_list/app_list_test_util.h"
+#include "chrome/browser/ui/app_list/search/chrome_search_result.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "url/gurl.h"
+
+namespace app_list {
+namespace test {
+
+using chromeos::assistant::AssistantAllowedState;
+
+class AssistantTextSearchProviderTest : public AppListTestBase {
+ public:
+  AssistantTextSearchProviderTest() = default;
+  AssistantTextSearchProviderTest(const AssistantTextSearchProviderTest&) =
+      delete;
+  AssistantTextSearchProviderTest& operator=(
+      const AssistantTextSearchProviderTest&) = delete;
+  ~AssistantTextSearchProviderTest() override = default;
+
+  void SendText(const std::string& text) {
+    search_provider_.Start(base::UTF8ToUTF16(text));
+  }
+
+  AssistantTextSearchProvider& search_provider() { return search_provider_; }
+
+  ash::MockAssistantState& assistant_state() { return assistant_state_; }
+
+  testing::NiceMock<ash::MockAssistantController>& assistant_controller() {
+    return assistant_controller_;
+  }
+
+  void VerifyResultAt(size_t index, const std::string& text) {
+    EXPECT_LT(index, search_provider().results().size());
+    auto* result = search_provider().results().at(0).get();
+    EXPECT_EQ(result->title(), base::UTF8ToUTF16(text));
+    EXPECT_EQ(result->id(), "googleassistant_text://" + text);
+    EXPECT_EQ(result->accessible_name(),
+              base::UTF8ToUTF16(text + ", Google Assistant"));
+    EXPECT_EQ(result->result_type(),
+              ash::AppListSearchResultType::kAssistantText);
+    EXPECT_EQ(result->display_type(), ash::SearchResultDisplayType::kList);
+  }
+
+ private:
+  ash::MockAssistantState assistant_state_;
+  testing::NiceMock<ash::MockAssistantController> assistant_controller_;
+  AssistantTextSearchProvider search_provider_;
+};
+
+// Tests -----------------------------------------------------------------------
+
+TEST_F(AssistantTextSearchProviderTest, ShouldNotProvideResultForEmptyQuery) {
+  EXPECT_TRUE(search_provider().results().empty());
+
+  SendText("testing");
+  // Should now have a search result with title "testing".
+  EXPECT_EQ(search_provider().results().size(), 1u);
+  VerifyResultAt(0, "testing");
+
+  SendText("");
+  // Should have no search results.
+  EXPECT_TRUE(search_provider().results().empty());
+}
+
+TEST_F(AssistantTextSearchProviderTest,
+       ShouldUpdateResultsWhenAssistantSettingsChange) {
+  SendText("testing");
+  EXPECT_EQ(search_provider().results().size(), 1u);
+
+  assistant_state().SetSettingsEnabled(false);
+  EXPECT_TRUE(search_provider().results().empty());
+
+  assistant_state().SetSettingsEnabled(true);
+  EXPECT_EQ(search_provider().results().size(), 1u);
+}
+
+TEST_F(AssistantTextSearchProviderTest,
+       ShouldUpdateResultsWhenAssistantAllowedStateChanges) {
+  SendText("testing");
+
+  // Test all possible Assistant allowed states.
+  for (int i = 0; i < static_cast<int>(AssistantAllowedState::MAX_VALUE); ++i) {
+    if (i == static_cast<int>(AssistantAllowedState::ALLOWED))
+      continue;
+
+    // When Assistant becomes not-allowed, results should be cleared.
+    assistant_state().SetAllowedState(static_cast<AssistantAllowedState>(i));
+    EXPECT_TRUE(search_provider().results().empty());
+
+    // When Assistant becomes allowed, we should again have a single result.
+    assistant_state().SetAllowedState(AssistantAllowedState::ALLOWED);
+    EXPECT_EQ(1u, search_provider().results().size());
+  }
+}
+TEST_F(AssistantTextSearchProviderTest, ShouldDeepLinkAssistantQuery) {
+  SendText("testing query");
+
+  GURL url;
+  bool in_background = true;
+  bool from_user = true;
+  EXPECT_CALL(assistant_controller(), OpenUrl)
+      .WillOnce(testing::DoAll(testing::SaveArg<0>(&url),
+                               testing::SaveArg<1>(&in_background),
+                               testing::SaveArg<2>(&from_user)));
+
+  search_provider().results().at(0)->Open(/*event_flags=*/0);
+  EXPECT_EQ(url, GURL("googleassistant://send-query?q=testing+query"));
+  EXPECT_FALSE(in_background);
+  EXPECT_FALSE(from_user);
+}
+
+}  // namespace test
+}  // namespace app_list

chrome/browser/ui/app_list/search/search_controller_factory.cc

@@ -23,6 +23,7 @@
 #include "chrome/browser/ui/app_list/search/arc/arc_app_shortcuts_search_provider.h"
 #include "chrome/browser/ui/app_list/search/arc/arc_playstore_search_provider.h"
 #include "chrome/browser/ui/app_list/search/assistant_search_provider.h"
+#include "chrome/browser/ui/app_list/search/assistant_text_search_provider.h"
 #include "chrome/browser/ui/app_list/search/drive_quick_access_provider.h"
 #include "chrome/browser/ui/app_list/search/launcher_search/launcher_search_provider.h"
 #include "chrome/browser/ui/app_list/search/mixer.h"
@@ -75,7 +76,9 @@ constexpr size_t kMaxAppShortcutResults = 4;
 
 // Assistant provides a single search result when launcher chip integration is
 // enabled from its internal cache of conversation starters.
-constexpr size_t kMaxAssistantResults = 1;
+constexpr size_t kMaxAssistantChipResults = 1;
+
+constexpr size_t kMaxAssistantTextResults = 1;
 
 // TODO(wutao): Need UX spec.
 constexpr size_t kMaxSettingsShortcutResults = 6;
@@ -117,11 +120,17 @@ std::unique_ptr<SearchController> CreateSearchController(
   // The Assistant search provider currently only contributes search results
   // when launcher chip integration is enabled.
   if (chromeos::assistant::features::IsLauncherChipIntegrationEnabled()) {
-    size_t assistant_group_id = controller->AddGroup(kMaxAssistantResults);
+    size_t assistant_group_id = controller->AddGroup(kMaxAssistantChipResults);
     controller->AddProvider(assistant_group_id,
                             std::make_unique<AssistantSearchProvider>());
   }
 
+  if (app_list_features::IsAssistantSearchEnabled()) {
+    size_t assistant_group_id = controller->AddGroup(kMaxAssistantTextResults);
+    controller->AddProvider(assistant_group_id,
+                            std::make_unique<AssistantTextSearchProvider>());
+  }
+
   // LauncherSearchProvider is added only when not in guest
   // session and running on Chrome OS.
   if (!profile->IsGuestSession()) {

chrome/browser/ui/app_list/search/search_result_ranker/ranking_item_util.cc

@@ -33,8 +33,9 @@ RankingItemType RankingItemTypeFromSearchResult(
     case ash::AppListSearchResultType::kAssistantChip:
     case ash::AppListSearchResultType::kOsSettings:
     case ash::AppListSearchResultType::kInternalPrivacyInfo:
-      // NOTE: We don't rank results of type kAssistantChip as the Assistant
-      // chip result, if present, is always shown in a dedicated slot.
+    case ash::AppListSearchResultType::kAssistantText:
+      // NOTE: We don't rank results of type kAssistantChip, kAssistantText
+      // as those results, if present, are shown in a dedicated slot.
       return RankingItemType::kIgnored;
     case ash::AppListSearchResultType::kArcAppShortcut:
       return RankingItemType::kArcAppShortcut;

chrome/test/BUILD.gn

@@ -4757,6 +4757,7 @@ test("unit_tests") {
       "../browser/ui/app_list/search/arc/arc_app_shortcuts_search_provider_unittest.cc",
       "../browser/ui/app_list/search/arc/arc_playstore_search_provider_unittest.cc",
       "../browser/ui/app_list/search/assistant_search_provider_unittest.cc",
+      "../browser/ui/app_list/search/assistant_text_search_provider_unittest.cc",
       "../browser/ui/app_list/search/cros_action_history/cros_action_recorder_tab_tracker_unittest.cc",
       "../browser/ui/app_list/search/cros_action_history/cros_action_recorder_unittest.cc",
       "../browser/ui/app_list/search/launcher_search/launcher_search_icon_image_loader_unittest.cc",