speedreader: Implement icon and tie it to bubbles

For this to work, we have our icon inherit from
dom_distiller::DistillabilityObserver to implement a one-shot mode, that
is familiar to existing reader modes by injecting a JS script to perform
scoring. That way if Speedreader doesn't support a site, the user can
still have it distill.

app/brave_command_ids.h

@@ -38,6 +38,7 @@
 #define IDC_APP_MENU_IPFS_IMPORT_LOCAL_FOLDER 56025
 #define IDC_SHOW_BRAVE_WALLET_PANEL 56026
 #define IDC_CLOSE_BRAVE_WALLET_PANEL 56027
+#define IDC_SPEEDREADER_ICON_ONCLICK 56028
 
 #define IDC_CONTENT_CONTEXT_IMPORT_IPNS_KEYS_START 56100
 #define IDC_CONTENT_CONTEXT_IMPORT_IPNS_KEYS_END 56199

app/brave_generated_resources.grd

@@ -1168,6 +1168,12 @@ By installing this extension, you are agreeing to the Google Widevine Terms of U
         <message name="IDS_PAGE_IS_DISTILLED" desc="Speedreader is enabled on this page">
           in Speedreader
         </message>
+        <message name="IDS_ICON_READER_MODE_LABEL" desc="Icon label indicating Speedreader is enabled">
+          Reader Mode
+        </message>
+        <message name="IDS_ICON_SPEEDREADER_MODE_LABEL" desc="Icon label indicating Speedreader is enabled">
+          Speedreader
+        </message>
       </if>
 
       <!-- P3A -->

browser/brave_content_browser_client.cc

@@ -128,6 +128,7 @@ using extensions::ChromeContentBrowserClientExtensionsPart;
 #include "brave/browser/speedreader/speedreader_tab_helper.h"
 #include "brave/components/speedreader/speedreader_throttle.h"
 #include "third_party/blink/public/mojom/loader/resource_load_info.mojom-shared.h"
+using DistillState = speedreader::SpeedreaderTabHelper::DistillState;
 #endif
 
 #if BUILDFLAG(BINANCE_ENABLED)
@@ -306,8 +307,7 @@ void BraveContentBrowserClient::BrowserURLHandlerCreated(
 void BraveContentBrowserClient::RenderProcessWillLaunch(
     content::RenderProcessHost* host) {
   Profile* profile = Profile::FromBrowserContext(host->GetBrowserContext());
-  BraveRendererUpdaterFactory::GetForProfile(profile)
-      ->InitializeRenderer(host);
+  BraveRendererUpdaterFactory::GetForProfile(profile)->InitializeRenderer(host);
 
   ChromeContentBrowserClient::RenderProcessWillLaunch(host);
 }
@@ -460,7 +460,8 @@ BraveContentBrowserClient::CreateURLLoaderThrottles(
   }
   auto* tab_helper =
       speedreader::SpeedreaderTabHelper::FromWebContents(contents);
-  if (tab_helper && tab_helper->IsActiveForMainFrame() &&
+  const auto state = tab_helper->PageDistillState();
+  if (tab_helper && state != DistillState::kNone &&
       request.resource_type ==
           static_cast<int>(blink::mojom::ResourceType::kMainFrame)) {
     std::unique_ptr<speedreader::SpeedReaderThrottle> throttle =
@@ -468,7 +469,8 @@ BraveContentBrowserClient::CreateURLLoaderThrottles(
             g_brave_browser_process->speedreader_rewriter_service(),
             HostContentSettingsMapFactory::GetForProfile(
                 Profile::FromBrowserContext(browser_context)),
-            request.url, base::ThreadTaskRunnerHandle::Get());
+            request.url, state == DistillState::kSpeedreaderMode,
+            base::ThreadTaskRunnerHandle::Get());
     if (throttle)
       result.push_back(std::move(throttle));
   }

browser/speedreader/speedreader_tab_helper.cc

@@ -36,6 +36,9 @@ bool SpeedreaderTabHelper::IsSpeedreaderEnabled() const {
 }
 
 bool SpeedreaderTabHelper::IsEnabledForSite() {
+  if (!IsSpeedreaderEnabled())
+    return false;
+
   Profile* profile =
       Profile::FromBrowserContext(web_contents()->GetBrowserContext());
   auto* content_rules = HostContentSettingsMapFactory::GetForProfile(profile);
@@ -44,6 +47,9 @@ bool SpeedreaderTabHelper::IsEnabledForSite() {
 }
 
 void SpeedreaderTabHelper::MaybeToggleEnabledForSite(bool on) {
+  if (!IsSpeedreaderEnabled())
+    return;
+
   Profile* profile =
       Profile::FromBrowserContext(web_contents()->GetBrowserContext());
   auto* content_rules = HostContentSettingsMapFactory::GetForProfile(profile);
@@ -56,15 +62,25 @@ void SpeedreaderTabHelper::MaybeToggleEnabledForSite(bool on) {
   }
 }
 
+void SpeedreaderTabHelper::SingleShotSpeedreader() {
+  single_shot_next_request_ = true;
+  auto* contents = web_contents();
+  if (contents)
+    contents->GetController().Reload(content::ReloadType::NORMAL, false);
+}
+
 void SpeedreaderTabHelper::UpdateActiveState(
     content::NavigationHandle* handle) {
   DCHECK(handle);
   DCHECK(handle->IsInMainFrame());
 
-  const bool enabled = IsSpeedreaderEnabled();
+  if (single_shot_next_request_) {
+    distill_state_ = DistillState::kReaderMode;
+    return;
+  }
 
-  if (!enabled) {
-    active_ = false;
+  if (!IsEnabledForSite()) {
+    distill_state_ = DistillState::kNone;
     return;
   }
 
@@ -75,11 +91,15 @@ void SpeedreaderTabHelper::UpdateActiveState(
     if (speedreader::IsWhitelistedForTest(handle->GetURL()) ||
         rewriter_service->IsWhitelisted(handle->GetURL())) {
       VLOG(2) << __func__ << " SpeedReader active for " << handle->GetURL();
-      active_ = true;
+      distill_state_ = DistillState::kSpeedreaderMode;
       return;
     }
   }
-  active_ = false;
+  distill_state_ = DistillState::kNone;
+}
+
+bool SpeedreaderTabHelper::IsActiveForMainFrame() const {
+  return distill_state_ != DistillState::kNone;
 }
 
 void SpeedreaderTabHelper::DidStartNavigation(
@@ -96,12 +116,23 @@ void SpeedreaderTabHelper::DidRedirectNavigation(
   }
 }
 
+void SpeedreaderTabHelper::DidStopLoading() {
+  // This will be called after the URLLoaders have already been created. If we
+  // are in single-shot mode, disable the Speedreader loader since that has
+  // completed.
+  single_shot_next_request_ = false;
+}
+
 SpeedreaderBubbleView* SpeedreaderTabHelper::speedreader_bubble_view() const {
   return speedreader_bubble_;
 }
 
 void SpeedreaderTabHelper::OnBubbleClosed() {
   speedreader_bubble_ = nullptr;
+  auto* contents = web_contents();
+  Browser* browser = chrome::FindBrowserWithWebContents(contents);
+  DCHECK(browser);
+  browser->window()->UpdatePageActionIcon(PageActionIconType::kReaderMode);
 }
 
 // Displays speedreader information
@@ -109,9 +140,10 @@ void SpeedreaderTabHelper::ShowBubble() {
   auto* contents = web_contents();
   Browser* browser = chrome::FindBrowserWithWebContents(contents);
   DCHECK(browser);
-  speedreader_bubble_ =
-      static_cast<BraveBrowserWindow*>(browser->window())
-          ->ShowSpeedreaderBubble(this, IsSpeedreaderEnabled());
+  const bool enabled = distill_state_ == DistillState::kSpeedreaderMode;
+  speedreader_bubble_ = static_cast<BraveBrowserWindow*>(browser->window())
+                            ->ShowSpeedreaderBubble(this, enabled);
+  browser->window()->UpdatePageActionIcon(PageActionIconType::kReaderMode);
 }
 
 // Hides speedreader information

browser/speedreader/speedreader_tab_helper.h

@@ -23,22 +23,35 @@ class SpeedreaderTabHelper
     : public content::WebContentsObserver,
       public content::WebContentsUserData<SpeedreaderTabHelper> {
  public:
+  enum class DistillState {
+    kNone,
+    kReaderMode,
+    kSpeedreaderMode,
+  };
   ~SpeedreaderTabHelper() override;
 
   SpeedreaderTabHelper(const SpeedreaderTabHelper&) = delete;
   SpeedreaderTabHelper& operator=(SpeedreaderTabHelper&) = delete;
 
-  bool IsActiveForMainFrame() const { return active_; }
+  bool IsActiveForMainFrame() const;
 
+  // Returns |true| if Speedreader is turned on for all sites.
   bool IsSpeedreaderEnabled() const;
 
-  // Returns |true| if the domain is speedreadable
+  // Returns |true| if the domain is Speedreader is enabled and the domain was
+  // not blacklisted by the user.
   bool IsEnabledForSite();
 
+  DistillState PageDistillState() const { return distill_state_; }
+
   // Allow or deny a site from being run through speedreader if |on| toggles
   // the setting. Triggers page reload on toggle.
   void MaybeToggleEnabledForSite(bool on);
 
+  // Reload the page and mark the next request to run through Speedreader,
+  // without turning it on. This mimics the standard reader mode.
+  void SingleShotSpeedreader();
+
   // returns nullptr if no bubble currently shown
   SpeedreaderBubbleView* speedreader_bubble_view() const;
 
@@ -62,8 +75,11 @@ class SpeedreaderTabHelper
       content::NavigationHandle* navigation_handle) override;
   void DidRedirectNavigation(
       content::NavigationHandle* navigation_handle) override;
+  void DidStopLoading() override;
 
-  bool active_ = false;  // speedreader active for this tab
+  bool single_shot_next_request_ =
+      false;  // run speedreader once on next page load
+  DistillState distill_state_ = DistillState::kNone;
   SpeedreaderBubbleView* speedreader_bubble_ = nullptr;
 
   WEB_CONTENTS_USER_DATA_KEY_DECL();

browser/ui/BUILD.gn

@@ -141,8 +141,6 @@ source_set("ui") {
       "views/frame/brave_opaque_browser_frame_view.h",
       "views/frame/brave_window_frame_graphic.cc",
       "views/frame/brave_window_frame_graphic.h",
-      "views/reader_mode/brave_reader_mode_icon_view.cc",
-      "views/reader_mode/brave_reader_mode_icon_view.h",
       "views/rounded_separator.cc",
       "views/rounded_separator.h",
       "views/speedreader/reader_mode_bubble.cc",
@@ -151,6 +149,8 @@ source_set("ui") {
       "views/speedreader/speedreader_bubble_util.h",
       "views/speedreader/speedreader_mode_bubble.cc",
       "views/speedreader/speedreader_mode_bubble.h",
+      "views/speedreader/speedreader_icon_view.cc",
+      "views/speedreader/speedreader_icon_view.h",
       "views/tabs/brave_browser_tab_strip_controller.cc",
       "views/tabs/brave_browser_tab_strip_controller.h",
       "views/tabs/brave_tab_context_menu_contents.cc",
@@ -235,6 +235,7 @@ source_set("ui") {
     "//brave/browser/gcm_driver",
     "//brave/browser/profiles",
     "//brave/browser/tor",
+    "//components/dom_distiller/content/browser",
 
     # //chrome/browser/ui depends on //brave/browser/ui, add this target here
     # to pull in dependencies needed for the overwrite codes in chromium_src.

browser/ui/brave_browser_command_controller.cc

@@ -150,6 +150,7 @@ void BraveBrowserCommandController::InitBraveCommandState() {
   UpdateCommandEnabled(IDC_ADD_NEW_PROFILE, add_new_profile_enabled);
   UpdateCommandEnabled(IDC_OPEN_GUEST_PROFILE, open_guest_profile_enabled);
   UpdateCommandEnabled(IDC_TOGGLE_SPEEDREADER, true);
+  UpdateCommandEnabled(IDC_SPEEDREADER_ICON_ONCLICK, true);
 }
 
 void BraveBrowserCommandController::UpdateCommandForBraveRewards() {
@@ -248,6 +249,9 @@ bool BraveBrowserCommandController::ExecuteBraveCommandWithDisposition(
     case IDC_TOGGLE_SPEEDREADER:
       brave::ToggleSpeedreader(browser_);
       break;
+    case IDC_SPEEDREADER_ICON_ONCLICK:
+      brave::ShowSpeedreaderBubble(browser_);
+      break;
     case IDC_SHOW_BRAVE_WALLET_PANEL:
       brave::ShowWalletBubble(browser_);
       break;

browser/ui/browser_commands.cc

@@ -30,6 +30,7 @@
 #include "brave/browser/speedreader/speedreader_service_factory.h"
 #include "brave/browser/speedreader/speedreader_tab_helper.h"
 #include "brave/components/speedreader/speedreader_service.h"
+using DistillState = speedreader::SpeedreaderTabHelper::DistillState;
 #endif
 
 #if BUILDFLAG(ENABLE_TOR)
@@ -97,6 +98,39 @@ void ToggleSpeedreader(Browser* browser) {
 #endif  // BUILDFLAG(ENABLE_SPEEDREADER)
 }
 
+void ShowSpeedreaderBubble(Browser* browser) {
+#if BUILDFLAG(ENABLE_SPEEDREADER)
+  speedreader::SpeedreaderService* service =
+      speedreader::SpeedreaderServiceFactory::GetForProfile(browser->profile());
+  if (service) {
+    WebContents* contents = browser->tab_strip_model()->GetActiveWebContents();
+    if (contents) {
+      auto* tab_helper =
+          speedreader::SpeedreaderTabHelper::FromWebContents(contents);
+      if (!tab_helper)
+        return;
+
+      const DistillState state = tab_helper->PageDistillState();
+      if (state == DistillState::kNone) {
+        // If this is called on an undistilled page, we single shot it.
+        tab_helper->SingleShotSpeedreader();
+
+        if (tab_helper->IsSpeedreaderEnabled())
+          return;
+      }
+
+      // If Speedreader is already enabled, don't show the bubble.
+      // fixme: we need to |or| with an "asked" counter
+      if (state == DistillState::kNone || state == DistillState::kReaderMode) {
+        if (tab_helper->IsSpeedreaderEnabled())
+          return;
+      }
+      tab_helper->ShowBubble();
+    }
+  }
+#endif  // BUILDFLAG(ENABLE_SPEEDREADER)
+}
+
 void ShowWalletBubble(Browser* browser) {
 #if BUILDFLAG(BRAVE_WALLET_ENABLED) && defined(TOOLKIT_VIEWS)
   static_cast<BraveBrowserView*>(browser->window())->CreateWalletBubble();

browser/ui/browser_commands.h

@@ -17,6 +17,7 @@ void OpenGuestProfile();
 void ToggleSpeedreader(Browser* browser);
 void ShowWalletBubble(Browser* browser);
 void CloseWalletBubble(Browser* browser);
+void ShowSpeedreaderBubble(Browser* browser);
 
 }  // namespace brave
 

browser/ui/views/reader_mode/brave_reader_mode_icon_view.cc

@@ -1,10 +0,0 @@
-// Copyright (c) 2019 The Brave Authors. All rights reserved.
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this file,
-// you can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "brave/browser/ui/views/reader_mode/brave_reader_mode_icon_view.h"
-
-void BraveReaderModeIconView::UpdateImpl() {
-  SetVisible(false);
-}

browser/ui/views/reader_mode/brave_reader_mode_icon_view.h

@@ -1,21 +0,0 @@
-// Copyright (c) 2019 The Brave Authors. All rights reserved.
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this file,
-// you can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef BRAVE_BROWSER_UI_VIEWS_READER_MODE_BRAVE_READER_MODE_ICON_VIEW_H_
-#define BRAVE_BROWSER_UI_VIEWS_READER_MODE_BRAVE_READER_MODE_ICON_VIEW_H_
-
-#include "chrome/browser/ui/views/reader_mode/reader_mode_icon_view.h"
-
-
-class BraveReaderModeIconView : public ReaderModeIconView {
- public:
-    using ReaderModeIconView::ReaderModeIconView;
- protected:
-    void UpdateImpl() override;
-
-  DISALLOW_COPY_AND_ASSIGN(BraveReaderModeIconView);
-};
-
-#endif  // BRAVE_BROWSER_UI_VIEWS_READER_MODE_BRAVE_READER_MODE_ICON_VIEW_H_

browser/ui/views/speedreader/reader_mode_bubble.cc

@@ -11,10 +11,13 @@
 
 #include "base/bind.h"
 #include "base/notreached.h"
+#include "brave/browser/speedreader/speedreader_service_factory.h"
 #include "brave/browser/speedreader/speedreader_tab_helper.h"
 #include "brave/browser/ui/views/speedreader/speedreader_bubble_util.h"
 #include "brave/common/url_constants.h"
+#include "brave/components/speedreader/speedreader_service.h"
 #include "brave/grit/brave_generated_resources.h"
+#include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/views/location_bar/location_bar_bubble_delegate_view.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/strings/grit/components_strings.h"
@@ -128,9 +131,13 @@ void ReaderModeBubble::Init() {
 }
 
 void ReaderModeBubble::OnButtonPressed(const ui::Event& event) {
-  // FIXME: Tie up this logic to the speedreader service. Enable Speedreader
-  // globally.
-  NOTIMPLEMENTED();
+  auto* contents = tab_helper_->web_contents();
+  Profile* profile = Profile::FromBrowserContext(contents->GetBrowserContext());
+  auto* speedreader_service = SpeedreaderServiceFactory::GetForProfile(profile);
+  speedreader_service->ToggleSpeedreader();
+  tab_helper_->web_contents()->GetController().Reload(
+      content::ReloadType::NORMAL, false);
+  CloseBubble();
 }
 
 void ReaderModeBubble::OnLinkClicked(const ui::Event& event) {

browser/ui/views/speedreader/speedreader_icon_view.cc

@@ -0,0 +1,155 @@
+// Copyright (c) 2019 The Brave Authors. All rights reserved.
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this file,
+// you can obtain one at http://mozilla.org/MPL/2.0/.
+
+#include "brave/browser/ui/views/speedreader/speedreader_icon_view.h"
+
+#include <string>
+
+#include "base/notreached.h"
+#include "base/strings/utf_string_conversions.h"
+#include "brave/app/brave_command_ids.h"
+#include "brave/app/vector_icons/vector_icons.h"
+#include "brave/browser/speedreader/speedreader_tab_helper.h"
+#include "brave/grit/brave_generated_resources.h"
+#include "chrome/app/chrome_command_ids.h"
+#include "chrome/browser/themes/theme_properties.h"
+#include "chrome/browser/ui/views/location_bar/location_bar_bubble_delegate_view.h"
+#include "chrome/browser/ui/views/page_action/page_action_icon_view.h"
+#include "chrome/grit/generated_resources.h"
+#include "components/dom_distiller/content/browser/distillable_page_utils.h"
+#include "components/dom_distiller/content/browser/uma_helper.h"
+#include "include/core/SkColor.h"
+#include "ui/base/l10n/l10n_util.h"
+#include "ui/base/theme_provider.h"
+#include "ui/views/animation/ink_drop_state.h"
+#include "ui/views/metadata/metadata_impl_macros.h"
+
+using DistillState = speedreader::SpeedreaderTabHelper::DistillState;
+
+namespace {
+SkColor kReaderIconColor = SkColorSetRGB(0x4c, 0x54, 0xd2);
+}  // anonymous namespace
+
+SpeedreaderIconView::SpeedreaderIconView(
+    CommandUpdater* command_updater,
+    IconLabelBubbleView::Delegate* icon_label_bubble_delegate,
+    PageActionIconView::Delegate* page_action_icon_delegate,
+    PrefService* pref_service)
+    : PageActionIconView(command_updater,
+                         IDC_SPEEDREADER_ICON_ONCLICK,
+                         this, /* Make ourselves the icon bubble delegate */
+                         page_action_icon_delegate),
+      icon_label_bubble_delegate_(icon_label_bubble_delegate) {
+  SetVisible(false);
+}
+
+SpeedreaderIconView::~SpeedreaderIconView() = default;
+
+void SpeedreaderIconView::UpdateImpl() {
+  auto* contents = GetWebContents();
+  if (!contents || !contents->GetLastCommittedURL().SchemeIsHTTPOrHTTPS()) {
+    SetVisible(false);
+    return;
+  }
+
+  if (GetHighlighted() && !IsBubbleShowing())
+    AnimateInkDrop(views::InkDropState::HIDDEN, nullptr);
+
+  if (contents != web_contents_) {
+    if (web_contents_)
+      dom_distiller::RemoveObserver(web_contents_, this);
+    web_contents_ = contents;
+    dom_distiller::AddObserver(web_contents_, this);
+  }
+
+  auto* tab_helper =
+      speedreader::SpeedreaderTabHelper::FromWebContents(web_contents_);
+  if (!tab_helper) {
+    SetVisible(false);
+    return;
+  }
+
+  const bool is_distilled = tab_helper->IsActiveForMainFrame();
+
+  if (!is_distilled) {
+    auto result = dom_distiller::GetLatestResult(web_contents_);
+    if (result) {
+      const bool visible = result->is_last && result->is_distillable;
+      SetVisible(visible);
+      label()->SetVisible(false);
+
+      if (GetVisible()) {
+        // Reset the icon color
+        const ui::ThemeProvider* tp = GetThemeProvider();
+        SkColor icon_color_default =
+            tp->GetColor(ThemeProperties::COLOR_TOOLBAR_BUTTON_ICON);
+        SetIconColor(icon_color_default);
+      }
+    }
+  }
+
+  if (is_distilled) {
+    const DistillState state = tab_helper->PageDistillState();
+    DCHECK(state != DistillState::kNone);
+
+    const int label_id = state == DistillState::kReaderMode
+                             ? IDS_ICON_READER_MODE_LABEL
+                             : IDS_ICON_SPEEDREADER_MODE_LABEL;
+    SetLabel(l10n_util::GetStringUTF16(label_id));
+    SetIconColor(kReaderIconColor);
+    SetVisible(true);
+    label()->SetVisible(true);
+  }
+}
+
+const gfx::VectorIcon& SpeedreaderIconView::GetVectorIcon() const {
+  return kSpeedreaderIcon;
+}
+
+std::u16string SpeedreaderIconView::GetTextForTooltipAndAccessibleName() const {
+  return l10n_util::GetStringUTF16(GetActive() ? IDS_EXIT_DISTILLED_PAGE
+                                               : IDS_DISTILL_PAGE);
+}
+
+void SpeedreaderIconView::OnExecuting(
+    PageActionIconView::ExecuteSource execute_source) {}
+
+views::BubbleDialogDelegate* SpeedreaderIconView::GetBubble() const {
+  auto* web_contents = GetWebContents();
+  if (!web_contents)
+    return nullptr;
+
+  auto* tab_helper =
+      speedreader::SpeedreaderTabHelper::FromWebContents(web_contents);
+  if (!tab_helper)
+    return nullptr;
+
+  return reinterpret_cast<LocationBarBubbleDelegateView*>(
+      tab_helper->speedreader_bubble_view());
+}
+
+SkColor SpeedreaderIconView::GetIconLabelBubbleSurroundingForegroundColor()
+    const {
+  // We can always return this since the text will be set to invisible on
+  // non-readable pages.
+  return kReaderIconColor;
+}
+
+SkColor SpeedreaderIconView::GetIconLabelBubbleInkDropColor() const {
+  return kReaderIconColor;
+  // return icon_label_bubble_delegate_->GetIconLabelBubbleBackgroundColor();
+}
+
+SkColor SpeedreaderIconView::GetIconLabelBubbleBackgroundColor() const {
+  return icon_label_bubble_delegate_->GetIconLabelBubbleBackgroundColor();
+}
+
+void SpeedreaderIconView::OnResult(
+    const dom_distiller::DistillabilityResult& result) {
+  Update();
+}
+
+BEGIN_METADATA(SpeedreaderIconView, PageActionIconView)
+END_METADATA

browser/ui/views/speedreader/speedreader_icon_view.h

@@ -0,0 +1,54 @@
+// Copyright (c) 2019 The Brave Authors. All rights reserved.
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this file,
+// you can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef BRAVE_BROWSER_UI_VIEWS_SPEEDREADER_SPEEDREADER_ICON_VIEW_H_
+#define BRAVE_BROWSER_UI_VIEWS_SPEEDREADER_SPEEDREADER_ICON_VIEW_H_
+
+#include "chrome/browser/ui/views/page_action/page_action_icon_view.h"
+#include "components/dom_distiller/content/browser/distillable_page_utils.h"
+#include "content/public/browser/web_contents_observer.h"
+#include "ui/views/metadata/metadata_header_macros.h"
+
+namespace content {
+class NavigationHandle;
+}  // namespace content
+
+class PrefService;
+
+class SpeedreaderIconView : public PageActionIconView,
+                            public IconLabelBubbleView::Delegate,
+                            public dom_distiller::DistillabilityObserver {
+ public:
+  METADATA_HEADER(SpeedreaderIconView);
+  SpeedreaderIconView(CommandUpdater* command_updater,
+                      IconLabelBubbleView::Delegate* icon_label_bubble_delegate,
+                      PageActionIconView::Delegate* page_action_icon_delegate,
+                      PrefService* pref_service);
+  SpeedreaderIconView(const SpeedreaderIconView&) = delete;
+  SpeedreaderIconView& operator=(const SpeedreaderIconView&) = delete;
+  ~SpeedreaderIconView() override;
+
+ protected:
+  // PageActionIconView:
+  const gfx::VectorIcon& GetVectorIcon() const override;
+  void OnExecuting(PageActionIconView::ExecuteSource execute_source) override;
+  views::BubbleDialogDelegate* GetBubble() const override;
+  std::u16string GetTextForTooltipAndAccessibleName() const override;
+  void UpdateImpl() override;
+
+  // IconLabelBubbleView::Delegate:
+  SkColor GetIconLabelBubbleSurroundingForegroundColor() const override;
+  SkColor GetIconLabelBubbleInkDropColor() const override;
+  SkColor GetIconLabelBubbleBackgroundColor() const override;
+
+  // dom_distiller::DistillabilityObserver:
+  void OnResult(const dom_distiller::DistillabilityResult& result) override;
+
+ private:
+  content::WebContents* web_contents_ = nullptr;
+  IconLabelBubbleView::Delegate* icon_label_bubble_delegate_ = nullptr;
+};
+
+#endif  // BRAVE_BROWSER_UI_VIEWS_SPEEDREADER_SPEEDREADER_ICON_VIEW_H_

chromium_src/chrome/browser/ui/views/page_action/page_action_icon_controller.cc

@@ -6,7 +6,7 @@
 #include "brave/browser/translate/buildflags/buildflags.h"
 #include "brave/browser/ui/views/location_bar/brave_star_view.h"
 #include "brave/browser/ui/views/translate/brave_translate_icon_view.h"
-#include "brave/browser/ui/views/reader_mode/brave_reader_mode_icon_view.h"
+#include "brave/browser/ui/views/speedreader/speedreader_icon_view.h"
 #include "chrome/browser/ui/page_action/page_action_icon_type.h"
 
 namespace {
@@ -25,7 +25,7 @@ constexpr PageActionIconType kUndefinedPageActionIconType =
 #if BUILDFLAG(ENABLE_BRAVE_TRANSLATE_EXTENSION)
 #define TranslateIconView BraveTranslateIconView
 #endif
-#define ReaderModeIconView BraveReaderModeIconView
+#define ReaderModeIconView SpeedreaderIconView
 #define StarView BraveStarView
 #include "../../../../../../../chrome/browser/ui/views/page_action/page_action_icon_controller.cc"
 #undef StarView

components/speedreader/speedreader_throttle.cc

@@ -24,9 +24,13 @@ SpeedReaderThrottle::MaybeCreateThrottleFor(
     SpeedreaderRewriterService* rewriter_service,
     HostContentSettingsMap* content_settings,
     const GURL& url,
+    bool check_disabled_sites,
     scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
-  if (!IsEnabledForSite(content_settings, url))
+  LOG(ERROR) << "creating throttle";
+  if (check_disabled_sites && !IsEnabledForSite(content_settings, url)) {
+    LOG(ERROR) << "not enabled for site";
     return nullptr;
+  }
   return std::make_unique<SpeedReaderThrottle>(rewriter_service, task_runner);
 }
 

components/speedreader/speedreader_throttle.h

@@ -32,6 +32,7 @@ class SpeedReaderThrottle : public blink::URLLoaderThrottle {
       SpeedreaderRewriterService* rewriter_service,
       HostContentSettingsMap* content_settings,
       const GURL& url,
+      bool check_disabled_sites,
       scoped_refptr<base::SingleThreadTaskRunner> task_runner);
 
   // |task_runner| is used to bind the right task runner for handling incoming

components/speedreader/speedreader_throttle_unittest.cc

@@ -70,7 +70,7 @@ TEST_F(SpeedreaderThrottleTest, AllowThrottle) {
   auto runner = content::GetUIThreadTaskRunner({});
   std::unique_ptr<SpeedReaderThrottle> throttle =
       SpeedReaderThrottle::MaybeCreateThrottleFor(nullptr, content_settings(),
-                                                  url(), runner);
+                                                  url(), false, runner);
   EXPECT_NE(throttle.get(), nullptr);
 }
 
@@ -80,16 +80,33 @@ TEST_F(SpeedreaderThrottleTest, ToggleThrottle) {
 
   speedreader::SetEnabledForSite(content_settings(), url(), false);
   throttle = SpeedReaderThrottle::MaybeCreateThrottleFor(
-      nullptr, content_settings(), url(), runner);
+      nullptr, content_settings(), url(), true, runner);
   EXPECT_EQ(throttle.get(), nullptr);
   // no other domains are affected by the rule.
   throttle = SpeedReaderThrottle::MaybeCreateThrottleFor(
-      nullptr, content_settings(), GURL("kevin.com"), runner);
+      nullptr, content_settings(), GURL("kevin.com"), true, runner);
   EXPECT_NE(throttle.get(), nullptr);
 
   speedreader::SetEnabledForSite(content_settings(), url(), true);
   throttle = SpeedReaderThrottle::MaybeCreateThrottleFor(
-      nullptr, content_settings(), url(), runner);
+      nullptr, content_settings(), url(), true, runner);
+  EXPECT_NE(throttle.get(), nullptr);
+}
+
+TEST_F(SpeedreaderThrottleTest, ThrottleIgnoreDisabled) {
+  auto runner = content::GetUIThreadTaskRunner({});
+  std::unique_ptr<SpeedReaderThrottle> throttle;
+
+  speedreader::SetEnabledForSite(content_settings(), url(), false);
+
+  throttle = SpeedReaderThrottle::MaybeCreateThrottleFor(
+      nullptr, content_settings(), url(), true /* check_disabled_sites */,
+      runner);
+  EXPECT_EQ(throttle.get(), nullptr);
+
+  throttle = SpeedReaderThrottle::MaybeCreateThrottleFor(
+      nullptr, content_settings(), url(), false /* check_disabled_sites */,
+      runner);
   EXPECT_NE(throttle.get(), nullptr);
 }
 
@@ -102,7 +119,7 @@ TEST_F(SpeedreaderThrottleTest, ThrottleNestedURL) {
   speedreader::SetEnabledForSite(
       content_settings(), GURL("https://brave.com/some/nested/page"), false);
   throttle = SpeedReaderThrottle::MaybeCreateThrottleFor(
-      nullptr, content_settings(), url(), runner);
+      nullptr, content_settings(), url(), true, runner);
   EXPECT_EQ(throttle.get(), nullptr);
 }
 

patches/chrome-browser-ui-views-page_action-page_action_icon_controller.cc.patch

@@ -0,0 +1,12 @@
+diff --git a/chrome/browser/ui/views/page_action/page_action_icon_controller.cc b/chrome/browser/ui/views/page_action/page_action_icon_controller.cc
+index 135bb8fba3abf0ee61d1e4a495c0df049d1618ce..a8eeb0e1f095c918656267679a417edc9218fa53 100644
+--- a/chrome/browser/ui/views/page_action/page_action_icon_controller.cc
++++ b/chrome/browser/ui/views/page_action/page_action_icon_controller.cc
+@@ -26,7 +26,6 @@
+ #include "chrome/browser/ui/views/page_action/zoom_view.h"
+ #include "chrome/browser/ui/views/passwords/manage_passwords_icon_views.h"
+ #include "chrome/browser/ui/views/qrcode_generator/qrcode_generator_icon_view.h"
+-#include "chrome/browser/ui/views/reader_mode/reader_mode_icon_view.h"
+ #include "chrome/browser/ui/views/send_tab_to_self/send_tab_to_self_icon_view.h"
+ #include "chrome/browser/ui/views/sharing/sharing_dialog_view.h"
+ #include "chrome/browser/ui/views/sharing/sharing_icon_view.h"