Preserve the user's line wrapping preference for view-source pages

This patch allows preserving the user's line wrapping preference for
view source pages when the "Line wrapping" checkbox is toggled. This is
made possible by the newly-introduced PersistentRendererPrefsService,
which serves as as communication bridge between blink and chrome,
allowing the preference to be stored in the most appropriate profile.

Fixed: 40161918
Change-Id: I315f10efaf7c08f288ba70e2b3103f0d84c8ca1c
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/6477032
Reviewed-by: Jan Keitel <jkeitel@google.com>
Reviewed-by: Alex Ilin <alexilin@chromium.org>
Commit-Queue: Alex Ilin <alexilin@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1458721}

chrome/browser/chrome_browser_interface_binders.cc

@@ -69,6 +69,7 @@
 #include "third_party/blink/public/mojom/loader/navigation_predictor.mojom.h"
 #include "third_party/blink/public/mojom/payments/payment_request.mojom.h"
 #include "third_party/blink/public/mojom/payments/secure_payment_confirmation_service.mojom.h"
+#include "third_party/blink/public/mojom/persistent_renderer_prefs.mojom.h"
 #include "third_party/blink/public/mojom/prerender/prerender.mojom.h"
 #include "third_party/blink/public/public_buildflags.h"
 #include "ui/accessibility/accessibility_features.h"
@@ -97,6 +98,7 @@
 #else
 #include "chrome/browser/badging/badge_manager.h"
 #include "chrome/browser/payments/payment_request_factory.h"
+#include "chrome/browser/prefs/persistent_renderer_prefs_manager.h"
 #include "chrome/browser/ui/views/side_panel/customize_chrome/customize_chrome_utils.h"
 #include "chrome/browser/web_applications/web_install_service_impl.h"
 #endif  // BUILDFLAG(IS_ANDROID)
@@ -475,6 +477,8 @@ void PopulateChromeFrameBinders(
 #else
   map->Add<blink::mojom::BadgeService>(
       base::BindRepeating(&badging::BadgeManager::BindFrameReceiverIfAllowed));
+  map->Add<blink::mojom::PersistentRendererPrefsService>(
+      base::BindRepeating(&PersistentRendererPrefsManager::BindFrameReceiver));
   if (base::FeatureList::IsEnabled(features::kWebPayments)) {
     map->Add<payments::mojom::PaymentRequest>(
         base::BindRepeating(&payments::CreatePaymentRequest));

chrome/browser/prefs/BUILD.gn

@@ -31,8 +31,16 @@ source_set("prefs") {
     "//components/sync_preferences",
     "//mojo/public/cpp/bindings",
     "//services/preferences/public/mojom",
+    "//third_party/blink/public/mojom:mojom_platform_headers",
     "//url",
   ]
+
+  if (!is_android) {
+    sources += [
+      "persistent_renderer_prefs_manager.h",
+      "persistent_renderer_prefs_manager_factory.h",
+    ]
+  }
 }
 
 source_set("impl") {
@@ -288,6 +296,10 @@ source_set("impl") {
       "//components/live_caption",
       "//components/live_caption:live_translate",
     ]
+    sources += [
+      "persistent_renderer_prefs_manager.cc",
+      "persistent_renderer_prefs_manager_factory.cc",
+    ]
   }
 
   if (enable_extensions) {
@@ -433,6 +445,10 @@ source_set("unit_tests") {
     "//ui/base",
     "//url",
   ]
+
+  if (!is_android) {
+    sources += [ "persistent_renderer_prefs_unittest.cc" ]
+  }
 }
 
 if (!is_android) {

chrome/browser/prefs/browser_prefs.cc

@@ -2299,6 +2299,8 @@ void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry,
   registry->RegisterIntegerPref(prefs::kLensOverlayStartCount, 0);
 
   registry->RegisterDictionaryPref(prefs::kReportingEndpoints);
+
+  registry->RegisterBooleanPref(prefs::kViewSourceLineWrappingEnabled, false);
 }
 
 void RegisterUserProfilePrefs(user_prefs::PrefRegistrySyncable* registry) {

chrome/browser/prefs/persistent_renderer_prefs_manager.cc

@@ -0,0 +1,41 @@
+// Copyright 2025 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "chrome/browser/prefs/persistent_renderer_prefs_manager.h"
+
+#include "chrome/browser/prefs/persistent_renderer_prefs_manager_factory.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/common/pref_names.h"
+#include "components/prefs/pref_service.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/render_frame_host.h"
+
+PersistentRendererPrefsManager::PersistentRendererPrefsManager(
+    PrefService& pref_service)
+    : pref_service_(pref_service) {}
+
+PersistentRendererPrefsManager::~PersistentRendererPrefsManager() = default;
+
+void PersistentRendererPrefsManager::SetViewSourceLineWrapping(bool value) {
+  pref_service_->SetBoolean(prefs::kViewSourceLineWrappingEnabled, value);
+}
+
+void PersistentRendererPrefsManager::BindFrameReceiver(
+    content::RenderFrameHost* frame,
+    mojo::PendingReceiver<blink::mojom::PersistentRendererPrefsService>
+        receiver) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+
+  auto* profile = Profile::FromBrowserContext(frame->GetBrowserContext());
+
+  auto* persistent_renderer_prefs_manager =
+      PersistentRendererPrefsManagerFactory::GetInstance()->GetForProfile(
+          profile);
+  if (!persistent_renderer_prefs_manager) {
+    return;
+  }
+
+  persistent_renderer_prefs_manager->receivers_.Add(
+      persistent_renderer_prefs_manager, std::move(receiver));
+}

chrome/browser/prefs/persistent_renderer_prefs_manager.h

@@ -0,0 +1,50 @@
+// Copyright 2025 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CHROME_BROWSER_PREFS_PERSISTENT_RENDERER_PREFS_MANAGER_H_
+#define CHROME_BROWSER_PREFS_PERSISTENT_RENDERER_PREFS_MANAGER_H_
+
+#include "base/memory/raw_ref.h"
+#include "components/keyed_service/core/keyed_service.h"
+#include "mojo/public/cpp/bindings/receiver_set.h"
+#include "third_party/blink/public/mojom/persistent_renderer_prefs.mojom.h"
+
+class PrefService;
+
+namespace content {
+class RenderFrameHost;
+}
+
+// This class is used for updating profile-specific renderer preferences
+// from within blink. See
+// third_party/blink/public/mojom/persistent_renderer_prefs.mojom for more
+// details.
+class PersistentRendererPrefsManager
+    : public KeyedService,
+      public blink::mojom::PersistentRendererPrefsService {
+ public:
+  explicit PersistentRendererPrefsManager(PrefService& pref_service);
+
+  PersistentRendererPrefsManager(const PersistentRendererPrefsManager&) =
+      delete;
+  PersistentRendererPrefsManager& operator=(
+      const PersistentRendererPrefsManager&) = delete;
+
+  ~PersistentRendererPrefsManager() override;
+
+  static void BindFrameReceiver(
+      content::RenderFrameHost* frame,
+      mojo::PendingReceiver<blink::mojom::PersistentRendererPrefsService>
+          receiver);
+
+ private:
+  friend class TestPersistentRendererPrefsManager;
+
+  void SetViewSourceLineWrapping(bool value) override;
+
+  const raw_ref<PrefService> pref_service_;
+  mojo::ReceiverSet<blink::mojom::PersistentRendererPrefsService> receivers_;
+};
+
+#endif  // CHROME_BROWSER_PREFS_PERSISTENT_RENDERER_PREFS_MANAGER_H_

chrome/browser/prefs/persistent_renderer_prefs_manager_factory.cc

@@ -0,0 +1,46 @@
+// Copyright 2025 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "chrome/browser/prefs/persistent_renderer_prefs_manager_factory.h"
+
+#include <memory>
+
+#include "base/memory/ptr_util.h"
+#include "base/no_destructor.h"
+#include "chrome/browser/prefs/persistent_renderer_prefs_manager.h"
+#include "chrome/browser/profiles/profile.h"
+#include "components/prefs/pref_service.h"
+
+// static
+PersistentRendererPrefsManager*
+PersistentRendererPrefsManagerFactory::GetForProfile(Profile* profile) {
+  return static_cast<PersistentRendererPrefsManager*>(
+      GetInstance()->GetServiceForBrowserContext(profile, true));
+}
+
+// static
+PersistentRendererPrefsManagerFactory*
+PersistentRendererPrefsManagerFactory::GetInstance() {
+  static base::NoDestructor<PersistentRendererPrefsManagerFactory> instance;
+  return instance.get();
+}
+
+PersistentRendererPrefsManagerFactory::PersistentRendererPrefsManagerFactory()
+    : ProfileKeyedServiceFactory(
+          "PersistentRendererPrefsManager",
+          ProfileSelections::Builder()
+              .WithRegular(ProfileSelection::kRedirectedToOriginal)
+              .WithGuest(ProfileSelection::kOwnInstance)
+              .WithAshInternals(ProfileSelection::kOwnInstance)
+              .Build()) {}
+
+PersistentRendererPrefsManagerFactory::
+    ~PersistentRendererPrefsManagerFactory() = default;
+
+std::unique_ptr<KeyedService>
+PersistentRendererPrefsManagerFactory::BuildServiceInstanceForBrowserContext(
+    content::BrowserContext* context) const {
+  return std::make_unique<PersistentRendererPrefsManager>(
+      *Profile::FromBrowserContext(context)->GetPrefs());
+}

chrome/browser/prefs/persistent_renderer_prefs_manager_factory.h

@@ -0,0 +1,44 @@
+// Copyright 2025 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CHROME_BROWSER_PREFS_PERSISTENT_RENDERER_PREFS_MANAGER_FACTORY_H_
+#define CHROME_BROWSER_PREFS_PERSISTENT_RENDERER_PREFS_MANAGER_FACTORY_H_
+
+#include "chrome/browser/profiles/profile_keyed_service_factory.h"
+
+namespace base {
+template <typename T>
+class NoDestructor;
+}
+
+class Profile;
+
+class PersistentRendererPrefsManager;
+
+// Singleton that provides access to Profile specific
+// PersistentRendererPrefsManagers.
+class PersistentRendererPrefsManagerFactory
+    : public ProfileKeyedServiceFactory {
+ public:
+  static PersistentRendererPrefsManager* GetForProfile(Profile* profile);
+
+  static PersistentRendererPrefsManagerFactory* GetInstance();
+
+  PersistentRendererPrefsManagerFactory(
+      const PersistentRendererPrefsManagerFactory&) = delete;
+  PersistentRendererPrefsManagerFactory& operator=(
+      const PersistentRendererPrefsManagerFactory&) = delete;
+
+ private:
+  friend base::NoDestructor<PersistentRendererPrefsManagerFactory>;
+
+  PersistentRendererPrefsManagerFactory();
+  ~PersistentRendererPrefsManagerFactory() override;
+
+  // BrowserContextKeyedServiceFactory
+  std::unique_ptr<KeyedService> BuildServiceInstanceForBrowserContext(
+      content::BrowserContext* profile) const override;
+};
+
+#endif  // CHROME_BROWSER_PREFS_PERSISTENT_RENDERER_PREFS_MANAGER_FACTORY_H_

chrome/browser/prefs/persistent_renderer_prefs_unittest.cc

@@ -0,0 +1,40 @@
+// Copyright 2025 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "base/memory/raw_ptr.h"
+#include "chrome/browser/prefs/persistent_renderer_prefs_manager.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/common/pref_names.h"
+#include "chrome/test/base/testing_profile.h"
+#include "components/prefs/pref_service.h"
+#include "content/public/test/browser_task_environment.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+class TestPersistentRendererPrefsManager : PersistentRendererPrefsManager {
+ public:
+  explicit TestPersistentRendererPrefsManager(PrefService& pref_service)
+      : PersistentRendererPrefsManager(pref_service) {}
+  void TestSetViewSourceLineWrapping(bool value) {
+    SetViewSourceLineWrapping(value);
+  }
+};
+
+// Observe that changes made through the persistent renderer prefs service are
+// reflected in the profile backing it.
+TEST(PersistentRendererPrefsTest, ObservePrefChanges) {
+  content::BrowserTaskEnvironment task_environment;
+  TestingProfile profile;
+  TestPersistentRendererPrefsManager persistent_renderer_prefs_manager(
+      *profile.GetPrefs());
+
+  EXPECT_FALSE(
+      profile.GetPrefs()->GetBoolean(prefs::kViewSourceLineWrappingEnabled));
+
+  persistent_renderer_prefs_manager.TestSetViewSourceLineWrapping(true);
+  EXPECT_TRUE(
+      profile.GetPrefs()->GetBoolean(prefs::kViewSourceLineWrappingEnabled));
+  persistent_renderer_prefs_manager.TestSetViewSourceLineWrapping(false);
+  EXPECT_FALSE(
+      profile.GetPrefs()->GetBoolean(prefs::kViewSourceLineWrappingEnabled));
+}

chrome/browser/profiles/chrome_browser_main_extra_parts_profiles.cc

@@ -324,6 +324,7 @@
 #include "chrome/browser/new_tab_page/promos/promo_service_factory.h"
 #include "chrome/browser/passage_embeddings/passage_embeddings_coordinator_factory.h"
 #include "chrome/browser/payments/payment_request_display_manager_factory.h"
+#include "chrome/browser/prefs/persistent_renderer_prefs_manager_factory.h"
 #include "chrome/browser/privacy_sandbox/privacy_sandbox_survey_desktop_controller_factory.h"
 #include "chrome/browser/profile_resetter/reset_report_uploader_factory.h"
 #include "chrome/browser/screen_ai/screen_ai_service_router_factory.h"
@@ -1121,6 +1122,7 @@ void ChromeBrowserMainExtraPartsProfiles::
   PermissionActionsHistoryFactory::GetInstance();
   PermissionDecisionAutoBlockerFactory::GetInstance();
 #if !BUILDFLAG(IS_ANDROID)
+  PersistentRendererPrefsManagerFactory::GetInstance();
   PinnedTabServiceFactory::GetInstance();
   PinnedToolbarActionsModelFactory::GetInstance();
 #endif

chrome/browser/renderer_preferences_util.cc

@@ -226,6 +226,9 @@ void UpdateFromSystemSettings(blink::RendererPreferences* prefs,
 #else
   prefs->focus_ring_color = SkColorSetRGB(0x10, 0x10, 0x10);
 #endif
+
+  prefs->view_source_line_wrap_enabled =
+      pref_service->GetBoolean(prefs::kViewSourceLineWrappingEnabled);
 }
 
 }  // namespace renderer_preferences_util

chrome/browser/ui/prefs/pref_watcher.cc

@@ -125,6 +125,9 @@ PrefWatcher::PrefWatcher(Profile* profile)
                                      renderer_callback);
 #endif
 
+  profile_pref_change_registrar_.Add(prefs::kViewSourceLineWrappingEnabled,
+                                     renderer_callback);
+
   PrefChangeRegistrar::NamedChangeCallback webkit_callback =
       base::BindRepeating(&PrefWatcher::OnWebPrefChanged,
                           base::Unretained(this));

chrome/common/pref_names.h

@@ -1995,6 +1995,11 @@ inline constexpr char kNetworkAnnotationBlocklist[] =
 inline constexpr char kReportingEndpoints[] =
     "enterprise_reporting.reporting_endpoints";
 
+// A boolean indicating if the "Line wrap" checkbox on view source pages should
+// be prepopulated.
+inline constexpr char kViewSourceLineWrappingEnabled[] =
+    "view_source.line_wrapping_enabled";
+
 #if BUILDFLAG(IS_CHROMEOS)
 // The state of the SkyVault migration of local files to the cloud.
 inline constexpr char kSkyVaultMigrationState[] = "skyvault.migration_state";

headless/lib/browser/DEPS

@@ -15,6 +15,7 @@ include_rules = [
   "+third_party/skia/include",
   "+third_party/blink/public/mojom/quota",
   "+third_party/blink/public/mojom/badging",
+  "+third_party/blink/public/mojom/persistent_renderer_prefs.mojom.h",
   "+third_party/blink/public/common/bluetooth/web_bluetooth_device_id.h",
   "+third_party/blink/public/common/client_hints/enabled_client_hints.h",
   "+third_party/blink/public/common/renderer_preferences/renderer_preferences.h",

headless/lib/browser/headless_content_browser_client.cc

@@ -149,6 +149,31 @@ class HeadlessContentBrowserClient::StubBadgeService
   mojo::ReceiverSet<blink::mojom::BadgeService> receivers_;
 };
 
+// As with the above stub BadgeService, a stub implementation of a
+// PersistentRendererPrefsService is needed since the service is
+// implemented in chrome, and thus won't be available here.
+class HeadlessContentBrowserClient::StubPersistentRendererPrefsService
+    : public blink::mojom::PersistentRendererPrefsService {
+ public:
+  StubPersistentRendererPrefsService() = default;
+  StubPersistentRendererPrefsService(
+      const StubPersistentRendererPrefsService&) = delete;
+  StubPersistentRendererPrefsService& operator=(
+      const StubPersistentRendererPrefsService&) = delete;
+  ~StubPersistentRendererPrefsService() override = default;
+
+  void Bind(mojo::PendingReceiver<blink::mojom::PersistentRendererPrefsService>
+                receiver) {
+    receivers_.Add(this, std::move(receiver));
+  }
+
+  // blink::mojom::PersistentRendererPrefsService:
+  void SetViewSourceLineWrapping(bool value) override {}
+
+ private:
+  mojo::ReceiverSet<blink::mojom::PersistentRendererPrefsService> receivers_;
+};
+
 HeadlessContentBrowserClient::HeadlessContentBrowserClient(
     HeadlessBrowserImpl* browser)
     : browser_(browser) {}
@@ -179,6 +204,9 @@ void HeadlessContentBrowserClient::RegisterBrowserInterfaceBindersForFrame(
     mojo::BinderMapWithContext<content::RenderFrameHost*>* map) {
   map->Add<blink::mojom::BadgeService>(base::BindRepeating(
       &HeadlessContentBrowserClient::BindBadgeService, base::Unretained(this)));
+  map->Add<blink::mojom::PersistentRendererPrefsService>(base::BindRepeating(
+      &HeadlessContentBrowserClient::BindPersistentRendererPrefsService,
+      base::Unretained(this)));
 }
 
 void HeadlessContentBrowserClient::
@@ -428,6 +456,18 @@ void HeadlessContentBrowserClient::BindBadgeService(
   stub_badge_service_->Bind(std::move(receiver));
 }
 
+void HeadlessContentBrowserClient::BindPersistentRendererPrefsService(
+    content::RenderFrameHost* render_frame_host,
+    mojo::PendingReceiver<blink::mojom::PersistentRendererPrefsService>
+        receiver) {
+  if (!stub_persistent_renderer_prefs_service_) {
+    stub_persistent_renderer_prefs_service_ =
+        std::make_unique<StubPersistentRendererPrefsService>();
+  }
+
+  stub_persistent_renderer_prefs_service_->Bind(std::move(receiver));
+}
+
 bool HeadlessContentBrowserClient::CanAcceptUntrustedExchangesIfNeeded() {
   // We require --user-data-dir flag too so that no dangerous changes are made
   // in the user's regular profile.

headless/lib/browser/headless_content_browser_client.h

@@ -15,6 +15,7 @@
 #include "headless/public/headless_browser.h"
 #include "services/network/network_service.h"
 #include "third_party/blink/public/mojom/badging/badging.mojom.h"
+#include "third_party/blink/public/mojom/persistent_renderer_prefs.mojom.h"
 
 namespace headless {
 
@@ -156,10 +157,17 @@ class HeadlessContentBrowserClient : public content::ContentBrowserClient {
  private:
   class StubBadgeService;
 
+  class StubPersistentRendererPrefsService;
+
   void BindBadgeService(
       content::RenderFrameHost* render_frame_host,
       mojo::PendingReceiver<blink::mojom::BadgeService> receiver);
 
+  void BindPersistentRendererPrefsService(
+      content::RenderFrameHost* render_frame_host,
+      mojo::PendingReceiver<blink::mojom::PersistentRendererPrefsService>
+          receiver);
+
   void HandleExplicitlyAllowedPorts(
       ::network::mojom::NetworkService* network_service);
   void SetEncryptionKey(::network::mojom::NetworkService* network_service);
@@ -168,6 +176,9 @@ class HeadlessContentBrowserClient : public content::ContentBrowserClient {
 
   std::unique_ptr<StubBadgeService> stub_badge_service_;
 
+  std::unique_ptr<StubPersistentRendererPrefsService>
+      stub_persistent_renderer_prefs_service_;
+
   std::unique_ptr<HeadlessBluetoothDelegate> bluetooth_delegate_;
 };
 

third_party/blink/common/BUILD.gn

@@ -267,6 +267,7 @@ source_set("common") {
     "use_counter/use_counter_feature.cc",
     "use_counter/use_counter_feature_tracker.cc",
     "user_agent/user_agent_metadata.cc",
+    "view_source/rendering_preferences.cc",
     "web_package/signed_exchange_consts.cc",
     "web_package/web_package_request_matcher.cc",
     "web_preferences/web_preferences.cc",

third_party/blink/common/renderer_preferences/renderer_preferences_mojom_traits.cc

@@ -130,6 +130,8 @@ bool StructTraits<blink::mojom::RendererPreferencesDataView,
 
   out->canvas_noise_token = data.canvas_noise_token();
 
+  out->view_source_line_wrap_enabled = data.view_source_line_wrap_enabled();
+
   return true;
 }
 

third_party/blink/common/view_source/rendering_preferences.cc

@@ -0,0 +1,23 @@
+// Copyright 2025 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "third_party/blink/public/common/view_source/rendering_preferences.h"
+
+namespace blink {
+
+namespace {
+bool preference = false;
+}  // namespace
+
+// static
+void ViewSourceLineWrappingPreference::Set(bool value) {
+  preference = value;
+}
+
+// static
+bool ViewSourceLineWrappingPreference::Get() {
+  return preference;
+}
+
+}  // namespace blink

third_party/blink/public/common/BUILD.gn

@@ -303,6 +303,7 @@ source_set("headers") {
     "use_counter/use_counter_feature_tracker.h",
     "user_agent/user_agent_brand_version_type.h",
     "user_agent/user_agent_metadata.h",
+    "view_source/rendering_preferences.h",
     "web_cache/web_cache_resource_type_stats.h",
     "web_package/signed_exchange_consts.h",
     "web_package/web_package_request_matcher.h",

third_party/blink/public/common/renderer_preferences/renderer_preferences.h

@@ -92,6 +92,9 @@ struct BLINK_COMMON_EXPORT RendererPreferences {
   bool uses_platform_autofill{false};
   std::vector<uint16_t> explicitly_allowed_network_ports;
   uint64_t canvas_noise_token{0};
+  // The default value must be false to avoid performance problems on very large
+  // source pages.
+  bool view_source_line_wrap_enabled{false};
 
   RendererPreferences();
   RendererPreferences(const RendererPreferences& other);

third_party/blink/public/common/renderer_preferences/renderer_preferences_mojom_traits.h

@@ -280,6 +280,11 @@ struct BLINK_COMMON_EXPORT
     return data.canvas_noise_token;
   }
 
+  static bool view_source_line_wrap_enabled(
+      const ::blink::RendererPreferences& data) {
+    return data.view_source_line_wrap_enabled;
+  }
+
   static bool Read(blink::mojom::RendererPreferencesDataView,
                    ::blink::RendererPreferences* out);
 };

third_party/blink/public/common/view_source/rendering_preferences.h

@@ -0,0 +1,21 @@
+// Copyright 2025 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef THIRD_PARTY_BLINK_PUBLIC_COMMON_VIEW_SOURCE_RENDERING_PREFERENCES_H_
+#define THIRD_PARTY_BLINK_PUBLIC_COMMON_VIEW_SOURCE_RENDERING_PREFERENCES_H_
+
+#include "third_party/blink/public/common/common_export.h"
+
+namespace blink {
+
+// A static class that stores a per-renderer process line wrapping preference
+// for view source pages, as sent by the browser.
+class BLINK_COMMON_EXPORT ViewSourceLineWrappingPreference final {
+ public:
+  static void Set(bool value);
+  static bool Get();
+};
+}  // namespace blink
+
+#endif  // THIRD_PARTY_BLINK_PUBLIC_COMMON_VIEW_SOURCE_RENDERING_PREFERENCES_H_

third_party/blink/public/mojom/BUILD.gn

@@ -187,6 +187,7 @@ mojom("mojom_platform") {
     "permissions_policy/document_policy_feature.mojom",
     "permissions_policy/policy_disposition.mojom",
     "permissions_policy/policy_value.mojom",
+    "persistent_renderer_prefs.mojom",
     "picture_in_picture/picture_in_picture.mojom",
     "picture_in_picture_window_options/picture_in_picture_window_options.mojom",
     "plugins/plugin_registry.mojom",

third_party/blink/public/mojom/persistent_renderer_prefs.mojom

@@ -0,0 +1,15 @@
+// Copyright 2025 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+module blink.mojom;
+
+// Interface for notifying the browser about changes to renderer
+// preferences. Please only expose new preferences after carefully
+// considering if it would be problematic if these preferences were to be
+// modified by a compromised renderer process.
+interface PersistentRendererPrefsService {
+  // Asks the browser process to remember the current line wrapping
+  // preference.
+  SetViewSourceLineWrapping(bool value);
+};

third_party/blink/public/mojom/renderer_preferences.mojom

@@ -205,4 +205,7 @@ struct RendererPreferences {
   // A randomized 64 bit token that is generated per browser session,
   // used for canvas noising.
   uint64 canvas_noise_token = 0;
+
+  // Whether line wrapping should be enabled by default in view source pages.
+  bool view_source_line_wrap_enabled = false;
 };

third_party/blink/renderer/core/exported/web_view_impl.cc

@@ -56,6 +56,7 @@
 #include "third_party/blink/public/common/page/page_zoom.h"
 #include "third_party/blink/public/common/renderer_preferences/renderer_preferences.h"
 #include "third_party/blink/public/common/switches.h"
+#include "third_party/blink/public/common/view_source/rendering_preferences.h"
 #include "third_party/blink/public/common/web_preferences/web_preferences.h"
 #include "third_party/blink/public/mojom/frame/frame_replication_state.mojom-blink.h"
 #include "third_party/blink/public/mojom/input/focus_type.mojom-blink.h"
@@ -3566,6 +3567,8 @@ void WebViewImpl::UpdateRendererPreferences(
 #endif
 
   CanvasNoiseToken::Set(renderer_preferences_.canvas_noise_token);
+  ViewSourceLineWrappingPreference::Set(
+      renderer_preferences_.view_source_line_wrap_enabled);
 
   MaybePreloadSystemFonts(GetPage());
 }

third_party/blink/renderer/core/html/html_view_source_document.cc

@@ -24,6 +24,8 @@
 
 #include "third_party/blink/renderer/core/html/html_view_source_document.h"
 
+#include "third_party/blink/public/common/view_source/rendering_preferences.h"
+#include "third_party/blink/public/mojom/persistent_renderer_prefs.mojom-blink.h"
 #include "third_party/blink/public/strings/grit/blink_strings.h"
 #include "third_party/blink/renderer/core/css/css_value_id_mappings.h"
 #include "third_party/blink/renderer/core/dom/events/event.h"
@@ -54,16 +56,32 @@
 
 namespace blink {
 
+static const char* const kLineWrapClass = "line-wrap";
+
 class ViewSourceEventListener : public NativeEventListener {
  public:
   ViewSourceEventListener(HTMLTableElement* table, HTMLInputElement* checkbox)
       : table_(table), checkbox_(checkbox) {}
 
-  void Invoke(ExecutionContext*, Event* event) override {
+  void Invoke(ExecutionContext* execution_context, Event* event) override {
     DCHECK_EQ(event->type(), event_type_names::kChange);
-    table_->setAttribute(html_names::kClassAttr, checkbox_->Checked()
-                                                     ? AtomicString("line-wrap")
-                                                     : g_empty_atom);
+    table_->setAttribute(
+        html_names::kClassAttr,
+        checkbox_->Checked() ? AtomicString(kLineWrapClass) : g_empty_atom);
+
+#if !BUILDFLAG(IS_ANDROID) && !BUILDFLAG(IS_FUCHSIA)
+    // TODO(crbug.com/40255878): The service is implemented in Chrome, so it may
+    // not be provided in other embedders. Ensure that case is handled properly.
+    // TODO(crbug.com/415945840): Implement the PersistentRendererPrefsService
+    // for Android WebViews, and remove the Android part of the above guard.
+    mojo::Remote<mojom::blink::PersistentRendererPrefsService>
+        persistent_renderer_prefs_service;
+    execution_context->GetBrowserInterfaceBroker().GetInterface(
+        persistent_renderer_prefs_service.BindNewPipeAndPassReceiver());
+    DCHECK(persistent_renderer_prefs_service);
+    persistent_renderer_prefs_service->SetViewSourceLineWrapping(
+        checkbox_->Checked());
+#endif
   }
 
   void Trace(Visitor* visitor) const override {
@@ -124,6 +142,12 @@ void HTMLViewSourceDocument::CreateContainingTable() {
       /*use_capture=*/false);
   checkbox->setAttribute(html_names::kAriaLabelAttr, WTF::AtomicString(Locale::DefaultLocale().QueryString(
                               IDS_VIEW_SOURCE_LINE_WRAP)));
+
+  if (ViewSourceLineWrappingPreference::Get()) {
+    table->setAttribute(html_names::kClassAttr, AtomicString(kLineWrapClass));
+    checkbox->SetChecked(true);
+  }
+
   auto* label = MakeGarbageCollected<HTMLLabelElement>(*this);
   label->ParserAppendChild(
       Text::Create(*this, WTF::AtomicString(Locale::DefaultLocale().QueryString(