From 34597973f2c9620888a4394810b24fa88dac02db Mon Sep 17 00:00:00 2001 From: John Turpish Date: Fri, 15 Nov 2024 15:05:31 -0500 Subject: [PATCH] Progress toward gr decompose (todo) static_py chromium_edits/133.0.6835.3/ --- .../chrome/browser/BUILD.gn.patch | 27 ++++ .../chrome/browser/about_flags.cc.patch | 38 +++++ ...me_autocomplete_scheme_classifier.cc.patch | 51 ++++++ .../chrome_content_browser_client.cc.patch | 81 ++++++++++ .../chrome/browser/flag-metadata.json.patch | 16 ++ .../chrome/browser/flag_descriptions.cc.patch | 16 ++ .../chrome/browser/flag_descriptions.h.patch | 24 +++ .../chrome/browser/ipfs_extra_parts.cc | 10 ++ .../chrome/browser/ipfs_extra_parts.h | 10 ++ .../chrome/browser/prefs/BUILD.gn.patch | 23 +++ .../browser/prefs/browser_prefs.cc.patch | 36 +++++ .../browser/shell_integration_mac.mm.patch | 13 ++ .../common/chrome_content_client.cc.patch | 17 ++ .../linux/common/desktop.template.patch | 13 ++ .../chrome/installer/util/shell_util.cc.patch | 20 +++ .../components/cbor/reader.cc.patch | 44 ++++++ .../components/cbor/reader.h.patch | 26 ++++ .../components/cbor/reader_unittest.cc.patch | 47 ++++++ .../components/cbor/values.cc.patch | 145 ++++++++++++++++++ .../components/cbor/values.h.patch | 79 ++++++++++ .../components/cbor/writer.cc.patch | 14 ++ .../components/cbor/writer_unittest.cc.patch | 36 +++++ .../clipboard_recent_content_generic.cc.patch | 13 ++ .../net/dns/dns_config_service_linux.cc.patch | 18 +++ .../weborigin/scheme_registry.cc.patch | 15 ++ .../133.0.6835.3/url/BUILD.gn.patch | 32 ++++ .../133.0.6835.3/url/url_canon.h.patch | 26 ++++ .../133.0.6835.3/url/url_canon_ipfs.cc | 54 +++++++ .../133.0.6835.3/url/url_util.cc.patch | 45 ++++++ cmake/patch.py | 80 +++++----- cmake/pylint_thresh.py | 14 +- cmake/release.py | 11 +- .../include/ipfs_client/gw/gateway_request.h | 4 +- .../src/ipfs_client/ctx/default_gateways.cc | 36 ++--- library/src/ipfs_client/gw/gateway_request.cc | 42 ++--- .../gw/gateway_request_unittest.cc | 3 +- library/src/ipfs_client/gw/gateway_state.cc | 2 +- .../gw/inline_request_handler_unittest.cc | 2 +- 38 files changed, 1087 insertions(+), 96 deletions(-) create mode 100644 chromium_edits/133.0.6835.3/chrome/browser/BUILD.gn.patch create mode 100644 chromium_edits/133.0.6835.3/chrome/browser/about_flags.cc.patch create mode 100644 chromium_edits/133.0.6835.3/chrome/browser/autocomplete/chrome_autocomplete_scheme_classifier.cc.patch create mode 100644 chromium_edits/133.0.6835.3/chrome/browser/chrome_content_browser_client.cc.patch create mode 100644 chromium_edits/133.0.6835.3/chrome/browser/flag-metadata.json.patch create mode 100644 chromium_edits/133.0.6835.3/chrome/browser/flag_descriptions.cc.patch create mode 100644 chromium_edits/133.0.6835.3/chrome/browser/flag_descriptions.h.patch create mode 100644 chromium_edits/133.0.6835.3/chrome/browser/ipfs_extra_parts.cc create mode 100644 chromium_edits/133.0.6835.3/chrome/browser/ipfs_extra_parts.h create mode 100644 chromium_edits/133.0.6835.3/chrome/browser/prefs/BUILD.gn.patch create mode 100644 chromium_edits/133.0.6835.3/chrome/browser/prefs/browser_prefs.cc.patch create mode 100644 chromium_edits/133.0.6835.3/chrome/browser/shell_integration_mac.mm.patch create mode 100644 chromium_edits/133.0.6835.3/chrome/common/chrome_content_client.cc.patch create mode 100644 chromium_edits/133.0.6835.3/chrome/installer/linux/common/desktop.template.patch create mode 100644 chromium_edits/133.0.6835.3/chrome/installer/util/shell_util.cc.patch create mode 100644 chromium_edits/133.0.6835.3/components/cbor/reader.cc.patch create mode 100644 chromium_edits/133.0.6835.3/components/cbor/reader.h.patch create mode 100644 chromium_edits/133.0.6835.3/components/cbor/reader_unittest.cc.patch create mode 100644 chromium_edits/133.0.6835.3/components/cbor/values.cc.patch create mode 100644 chromium_edits/133.0.6835.3/components/cbor/values.h.patch create mode 100644 chromium_edits/133.0.6835.3/components/cbor/writer.cc.patch create mode 100644 chromium_edits/133.0.6835.3/components/cbor/writer_unittest.cc.patch create mode 100644 chromium_edits/133.0.6835.3/components/open_from_clipboard/clipboard_recent_content_generic.cc.patch create mode 100644 chromium_edits/133.0.6835.3/net/dns/dns_config_service_linux.cc.patch create mode 100644 chromium_edits/133.0.6835.3/third_party/blink/renderer/platform/weborigin/scheme_registry.cc.patch create mode 100644 chromium_edits/133.0.6835.3/url/BUILD.gn.patch create mode 100644 chromium_edits/133.0.6835.3/url/url_canon.h.patch create mode 100644 chromium_edits/133.0.6835.3/url/url_canon_ipfs.cc create mode 100644 chromium_edits/133.0.6835.3/url/url_util.cc.patch diff --git a/chromium_edits/133.0.6835.3/chrome/browser/BUILD.gn.patch b/chromium_edits/133.0.6835.3/chrome/browser/BUILD.gn.patch new file mode 100644 index 00000000..ea7987d5 --- /dev/null +++ b/chromium_edits/133.0.6835.3/chrome/browser/BUILD.gn.patch @@ -0,0 +1,27 @@ +diff --git a/chrome/browser/BUILD.gn b/chrome/browser/BUILD.gn +index fdfa082c1cfae..8a212006c6ca7 100644 +--- a/chrome/browser/BUILD.gn ++++ b/chrome/browser/BUILD.gn +@@ -42,6 +42,7 @@ import("//sandbox/features.gni") + import("//services/screen_ai/buildflags/features.gni") + import("//testing/libfuzzer/fuzzer_test.gni") + import("//third_party/blink/public/public_features.gni") ++import("//third_party/ipfs_client/args.gni") + import("//third_party/protobuf/proto_library.gni") + import("//third_party/webrtc/webrtc.gni") + import("//third_party/widevine/cdm/widevine.gni") +@@ -2496,6 +2497,14 @@ static_library("browser") { + "//ui/webui", + ] + ++ if (enable_ipfs) { ++ sources += [ ++ "ipfs_extra_parts.cc", ++ "ipfs_extra_parts.h", ++ ] ++ deps += [ "//components/ipfs" ] ++ } ++ + # Platforms that have a network diagnostics dialog. All others fall through + # to the stub which is not implemented. + if (is_chromeos_ash) { diff --git a/chromium_edits/133.0.6835.3/chrome/browser/about_flags.cc.patch b/chromium_edits/133.0.6835.3/chrome/browser/about_flags.cc.patch new file mode 100644 index 00000000..cd188806 --- /dev/null +++ b/chromium_edits/133.0.6835.3/chrome/browser/about_flags.cc.patch @@ -0,0 +1,38 @@ +diff --git a/chrome/browser/about_flags.cc b/chrome/browser/about_flags.cc +index c1e77252730c7..8659a01be9d50 100644 +--- a/chrome/browser/about_flags.cc ++++ b/chrome/browser/about_flags.cc +@@ -231,6 +231,7 @@ + #include "third_party/blink/public/common/features_generated.h" + #include "third_party/blink/public/common/forcedark/forcedark_switches.h" + #include "third_party/blink/public/common/switches.h" ++#include "third_party/ipfs_client/ipfs_buildflags.h" + #include "ui/accessibility/accessibility_features.h" + #include "ui/accessibility/accessibility_switches.h" + #include "ui/base/ozone_buildflags.h" +@@ -336,6 +337,10 @@ + #include "extensions/common/switches.h" + #endif // BUILDFLAG(ENABLE_EXTENSIONS) + ++#if BUILDFLAG(ENABLE_IPFS) ++#include "components/ipfs/ipfs_features.h" ++#endif ++ + #if BUILDFLAG(ENABLE_PDF) + #include "pdf/pdf_features.h" + #endif +@@ -9664,6 +9669,14 @@ const FeatureEntry kFeatureEntries[] = { + flag_descriptions::kOmitCorsClientCertDescription, kOsAll, + FEATURE_VALUE_TYPE(network::features::kOmitCorsClientCert)}, + ++#if BUILDFLAG(ENABLE_IPFS) ++ {"enable-ipfs", ++ flag_descriptions::kEnableIpfsName, ++ flag_descriptions::kEnableIpfsDescription, ++ kOsMac | kOsWin | kOsLinux,//TODO: These are the only variants currently getting built, but that is not likely to remain the case ++ FEATURE_VALUE_TYPE(ipfs::kEnableIpfs)}, ++#endif ++ + {"use-idna2008-non-transitional", + flag_descriptions::kUseIDNA2008NonTransitionalName, + flag_descriptions::kUseIDNA2008NonTransitionalDescription, kOsAll, diff --git a/chromium_edits/133.0.6835.3/chrome/browser/autocomplete/chrome_autocomplete_scheme_classifier.cc.patch b/chromium_edits/133.0.6835.3/chrome/browser/autocomplete/chrome_autocomplete_scheme_classifier.cc.patch new file mode 100644 index 00000000..2bbe24d6 --- /dev/null +++ b/chromium_edits/133.0.6835.3/chrome/browser/autocomplete/chrome_autocomplete_scheme_classifier.cc.patch @@ -0,0 +1,51 @@ +diff --git a/chrome/browser/autocomplete/chrome_autocomplete_scheme_classifier.cc b/chrome/browser/autocomplete/chrome_autocomplete_scheme_classifier.cc +index a4a306c760f44..35dc091513f49 100644 +--- a/chrome/browser/autocomplete/chrome_autocomplete_scheme_classifier.cc ++++ b/chrome/browser/autocomplete/chrome_autocomplete_scheme_classifier.cc +@@ -13,6 +13,7 @@ + #include "chrome/browser/profiles/profile_io_data.h" + #include "components/custom_handlers/protocol_handler_registry.h" + #include "content/public/common/url_constants.h" ++#include "third_party/ipfs_client/ipfs_buildflags.h" + #include "url/url_util.h" + + #if BUILDFLAG(IS_ANDROID) +@@ -20,6 +21,11 @@ + #include "chrome/browser/ui/android/omnibox/jni_headers/ChromeAutocompleteSchemeClassifier_jni.h" + #endif + ++#if BUILDFLAG(ENABLE_IPFS) ++#include "components/ipfs/ipfs_features.h" ++#endif ++ ++ + #if BUILDFLAG(IS_ANDROID) + static jlong + JNI_ChromeAutocompleteSchemeClassifier_CreateAutocompleteClassifier( +@@ -53,12 +59,20 @@ ChromeAutocompleteSchemeClassifier::GetInputTypeForScheme( + if (scheme.empty()) { + return metrics::OmniboxInputType::EMPTY; + } +- if (base::IsStringASCII(scheme) && +- (ProfileIOData::IsHandledProtocol(scheme) || +- base::EqualsCaseInsensitiveASCII(scheme, content::kViewSourceScheme) || +- base::EqualsCaseInsensitiveASCII(scheme, url::kJavaScriptScheme) || +- base::EqualsCaseInsensitiveASCII(scheme, url::kDataScheme))) { +- return metrics::OmniboxInputType::URL; ++ if (base::IsStringASCII(scheme)) { ++ if (ProfileIOData::IsHandledProtocol(scheme) || ++ base::EqualsCaseInsensitiveASCII(scheme, content::kViewSourceScheme) || ++ base::EqualsCaseInsensitiveASCII(scheme, url::kJavaScriptScheme) || ++ base::EqualsCaseInsensitiveASCII(scheme, url::kDataScheme)) { ++ return metrics::OmniboxInputType::URL; ++ } ++#if BUILDFLAG(ENABLE_IPFS) ++ if (base::FeatureList::IsEnabled(ipfs::kEnableIpfs) && ++ (base::EqualsCaseInsensitiveASCII(scheme, "ipfs") || base::EqualsCaseInsensitiveASCII(scheme, "ipns")) ++ ) { ++ return metrics::OmniboxInputType::URL; ++ } ++#endif + } + + // Also check for schemes registered via registerProtocolHandler(), which diff --git a/chromium_edits/133.0.6835.3/chrome/browser/chrome_content_browser_client.cc.patch b/chromium_edits/133.0.6835.3/chrome/browser/chrome_content_browser_client.cc.patch new file mode 100644 index 00000000..328ff34c --- /dev/null +++ b/chromium_edits/133.0.6835.3/chrome/browser/chrome_content_browser_client.cc.patch @@ -0,0 +1,81 @@ +diff --git a/chrome/browser/chrome_content_browser_client.cc b/chrome/browser/chrome_content_browser_client.cc +index 25b5c325f612d..254f41914236e 100644 +--- a/chrome/browser/chrome_content_browser_client.cc ++++ b/chrome/browser/chrome_content_browser_client.cc +@@ -409,6 +409,7 @@ + #include "third_party/blink/public/mojom/browsing_topics/browsing_topics.mojom.h" + #include "third_party/blink/public/mojom/use_counter/metrics/web_feature.mojom.h" + #include "third_party/blink/public/public_buildflags.h" ++#include "third_party/ipfs_client/ipfs_buildflags.h" + #include "third_party/widevine/cdm/buildflags.h" + #include "ui/base/clipboard/clipboard_format_type.h" + #include "ui/base/l10n/l10n_util.h" +@@ -535,6 +536,13 @@ + #include "chrome/browser/chrome_browser_main_posix.h" + #endif + ++#if BUILDFLAG(ENABLE_IPFS) ++#include "chrome/browser/ipfs_extra_parts.h" ++#include "components/ipfs/interceptor.h" ++#include "components/ipfs/ipfs_features.h" ++#include "components/ipfs/url_loader_factory.h" ++#endif ++ + #if !BUILDFLAG(IS_ANDROID) + #include "chrome/browser/digital_credentials/digital_identity_provider_desktop.h" + #include "chrome/browser/preloading/preview/preview_navigation_throttle.h" +@@ -1876,6 +1884,11 @@ ChromeContentBrowserClient::CreateBrowserMainParts(bool is_integration_test) { + main_parts->AddParts( + std::make_unique()); + ++#if BUILDFLAG(ENABLE_IPFS) ++ if (base::FeatureList::IsEnabled(ipfs::kEnableIpfs)) { ++ main_parts->AddParts(std::make_unique()); ++ } ++#endif + return main_parts; + } + +@@ -6573,12 +6586,29 @@ void ChromeContentBrowserClient:: + const std::optional& request_initiator_origin, + NonNetworkURLLoaderFactoryMap* factories) { + #if BUILDFLAG(IS_CHROMEOS_ASH) || BUILDFLAG(ENABLE_EXTENSIONS) || \ +- !BUILDFLAG(IS_ANDROID) ++ !BUILDFLAG(IS_ANDROID) || BUILDFLAG(ENABLE_IPFS) + content::RenderFrameHost* frame_host = + RenderFrameHost::FromID(render_process_id, render_frame_id); + WebContents* web_contents = WebContents::FromRenderFrameHost(frame_host); + #endif // BUILDFLAG(IS_CHROMEOS_ASH) || BUILDFLAG(ENABLE_EXTENSIONS) || \ + // !BUILDFLAG(IS_ANDROID) ++#if BUILDFLAG(ENABLE_IPFS) ++ if (!web_contents) { ++ VLOG(2) << "No web contents, can't register url loader factory."; ++ } else if (base::FeatureList::IsEnabled(ipfs::kEnableIpfs)) { ++ network::mojom::URLLoaderFactory* default_factory = g_browser_process->system_network_context_manager()->GetURLLoaderFactory(); ++ auto* context = web_contents->GetBrowserContext(); ++ ipfs::IpfsURLLoaderFactory::Create( ++ factories, ++ context, ++ default_factory, ++ GetSystemNetworkContext(), ++ Profile::FromBrowserContext(context)->GetPrefs() ++ ); ++ } else { ++ LOG(INFO) << "IPFS disabled."; ++ } ++#endif // BUILDFLAG(ENABLE_IPFS) + + #if BUILDFLAG(IS_CHROMEOS_ASH) + if (web_contents) { +@@ -6726,6 +6756,11 @@ ChromeContentBrowserClient::WillCreateURLLoaderRequestInterceptors( + scoped_refptr navigation_response_task_runner) { + std::vector> + interceptors; ++#if BUILDFLAG(ENABLE_IPFS) ++ if (base::FeatureList::IsEnabled(ipfs::kEnableIpfs)) { ++ interceptors.push_back(std::make_unique(g_browser_process->system_network_context_manager()->GetURLLoaderFactory(), GetSystemNetworkContext())); ++ } ++#endif + #if BUILDFLAG(ENABLE_OFFLINE_PAGES) + interceptors.push_back( + std::make_unique( diff --git a/chromium_edits/133.0.6835.3/chrome/browser/flag-metadata.json.patch b/chromium_edits/133.0.6835.3/chrome/browser/flag-metadata.json.patch new file mode 100644 index 00000000..2b834624 --- /dev/null +++ b/chromium_edits/133.0.6835.3/chrome/browser/flag-metadata.json.patch @@ -0,0 +1,16 @@ +diff --git a/chrome/browser/flag-metadata.json b/chrome/browser/flag-metadata.json +index bed4f0058c0b7..6e5015a2a2a20 100644 +--- a/chrome/browser/flag-metadata.json ++++ b/chrome/browser/flag-metadata.json +@@ -3293,6 +3293,11 @@ + "owners": [ "adamta@google.com", "bling-get-set-up@google.com" ], + "expiry_milestone": 140 + }, ++ { ++ "name": "enable-ipfs", ++ "owners": [ "//components/ipfs/OWNERS" ], ++ "expiry_milestone": 150 ++ }, + { + "name": "enable-isolated-sandboxed-iframes", + "owners": [ "wjmaclean@chromium.org", "alexmos@chromium.org", "creis@chromium.org" ], diff --git a/chromium_edits/133.0.6835.3/chrome/browser/flag_descriptions.cc.patch b/chromium_edits/133.0.6835.3/chrome/browser/flag_descriptions.cc.patch new file mode 100644 index 00000000..be7363bb --- /dev/null +++ b/chromium_edits/133.0.6835.3/chrome/browser/flag_descriptions.cc.patch @@ -0,0 +1,16 @@ +diff --git a/chrome/browser/flag_descriptions.cc b/chrome/browser/flag_descriptions.cc +index 72bc44487e033..eccec4effa2d9 100644 +--- a/chrome/browser/flag_descriptions.cc ++++ b/chrome/browser/flag_descriptions.cc +@@ -376,6 +376,11 @@ const char kEnableBookmarksSelectedTypeOnSigninForTestingDescription[] = + "sync-enable-bookmarks-in-transport-mode. Enables the bookmarks " + "UserSelectableType upon sign-in"; + ++#if BUILDFLAG(ENABLE_IPFS) ++extern const char kEnableIpfsName[] = "Enable IPFS"; ++extern const char kEnableIpfsDescription[] = "Enable ipfs:// and ipns:// URLs"; ++#endif ++ + const char kPreloadingOnPerformancePageName[] = + "Preloading Settings on Performance Page"; + const char kPreloadingOnPerformancePageDescription[] = diff --git a/chromium_edits/133.0.6835.3/chrome/browser/flag_descriptions.h.patch b/chromium_edits/133.0.6835.3/chrome/browser/flag_descriptions.h.patch new file mode 100644 index 00000000..a0f05f9f --- /dev/null +++ b/chromium_edits/133.0.6835.3/chrome/browser/flag_descriptions.h.patch @@ -0,0 +1,24 @@ +diff --git a/chrome/browser/flag_descriptions.h b/chrome/browser/flag_descriptions.h +index 130a09c4eb439..782a8b731e03d 100644 +--- a/chrome/browser/flag_descriptions.h ++++ b/chrome/browser/flag_descriptions.h +@@ -25,6 +25,7 @@ + #include "printing/buildflags/buildflags.h" + #include "skia/buildflags.h" + #include "third_party/blink/public/common/buildflags.h" ++#include "third_party/ipfs_client/ipfs_buildflags.h" + + // This file declares strings used in chrome://flags. These messages are not + // translated, because instead of end-users they target Chromium developers and +@@ -228,6 +229,11 @@ extern const char kEnableBenchmarkingChoiceMatchFieldTrialTestingConfig[]; + extern const char kEnableBookmarksSelectedTypeOnSigninForTestingName[]; + extern const char kEnableBookmarksSelectedTypeOnSigninForTestingDescription[]; + ++#if BUILDFLAG(ENABLE_IPFS) ++extern const char kEnableIpfsName[]; ++extern const char kEnableIpfsDescription[]; ++#endif ++ + extern const char kFontationsFontBackendName[]; + extern const char kFontationsFontBackendDescription[]; + diff --git a/chromium_edits/133.0.6835.3/chrome/browser/ipfs_extra_parts.cc b/chromium_edits/133.0.6835.3/chrome/browser/ipfs_extra_parts.cc new file mode 100644 index 00000000..90d2596f --- /dev/null +++ b/chromium_edits/133.0.6835.3/chrome/browser/ipfs_extra_parts.cc @@ -0,0 +1,10 @@ +#include "ipfs_extra_parts.h" + +#include "profiles/profile.h" + +#include + +void IpfsExtraParts::PostProfileInit(Profile* profile, bool /* is_initial_profile */ ) { + DCHECK(profile); + ipfs::InterRequestState::CreateForBrowserContext(profile, profile->GetPrefs()); +} diff --git a/chromium_edits/133.0.6835.3/chrome/browser/ipfs_extra_parts.h b/chromium_edits/133.0.6835.3/chrome/browser/ipfs_extra_parts.h new file mode 100644 index 00000000..2059c437 --- /dev/null +++ b/chromium_edits/133.0.6835.3/chrome/browser/ipfs_extra_parts.h @@ -0,0 +1,10 @@ +#ifndef IPFS_EXTRA_PART_H_ +#define IPFS_EXTRA_PART_H_ + +#include + +class IpfsExtraParts : public ChromeBrowserMainExtraParts { + void PostProfileInit(Profile* profile, bool is_initial_profile) override; +}; + +#endif // IPFS_EXTRA_PART_H_ diff --git a/chromium_edits/133.0.6835.3/chrome/browser/prefs/BUILD.gn.patch b/chromium_edits/133.0.6835.3/chrome/browser/prefs/BUILD.gn.patch new file mode 100644 index 00000000..a867c5b9 --- /dev/null +++ b/chromium_edits/133.0.6835.3/chrome/browser/prefs/BUILD.gn.patch @@ -0,0 +1,23 @@ +diff --git a/chrome/browser/prefs/BUILD.gn b/chrome/browser/prefs/BUILD.gn +index 156a2f34d89f5..7f17b564e36df 100644 +--- a/chrome/browser/prefs/BUILD.gn ++++ b/chrome/browser/prefs/BUILD.gn +@@ -7,6 +7,7 @@ import("//components/safe_browsing/buildflags.gni") + import("//components/services/on_device_translation/buildflags/features.gni") + import("//extensions/buildflags/buildflags.gni") + import("//pdf/features.gni") ++import("//third_party/ipfs_client/args.gni") + + assert(is_win || is_mac || is_linux || is_chromeos || is_android) + +@@ -126,7 +127,9 @@ source_set("impl") { + "//services/preferences/public/mojom", + "//services/preferences/tracked", + ] +- ++ if (enable_ipfs) { ++ deps += [ "//components/ipfs" ] ++ } + if (is_chromeos) { + deps += [ + "//ash", diff --git a/chromium_edits/133.0.6835.3/chrome/browser/prefs/browser_prefs.cc.patch b/chromium_edits/133.0.6835.3/chrome/browser/prefs/browser_prefs.cc.patch new file mode 100644 index 00000000..23de7d29 --- /dev/null +++ b/chromium_edits/133.0.6835.3/chrome/browser/prefs/browser_prefs.cc.patch @@ -0,0 +1,36 @@ +diff --git a/chrome/browser/prefs/browser_prefs.cc b/chrome/browser/prefs/browser_prefs.cc +index a6002045888c4..d7434b3851b22 100644 +--- a/chrome/browser/prefs/browser_prefs.cc ++++ b/chrome/browser/prefs/browser_prefs.cc +@@ -197,6 +197,7 @@ + #include "ppapi/buildflags/buildflags.h" + #include "printing/buildflags/buildflags.h" + #include "rlz/buildflags/buildflags.h" ++#include "third_party/ipfs_client/ipfs_buildflags.h" + + #if BUILDFLAG(ENABLE_BACKGROUND_MODE) + #include "chrome/browser/background/background_mode_manager.h" +@@ -245,6 +246,11 @@ + #include "chrome/browser/pdf/pdf_pref_names.h" + #endif // BUILDFLAG(ENABLE_PDF) + ++#if BUILDFLAG(ENABLE_IPFS) ++#include "components/ipfs/ipfs_features.h" ++#include "components/ipfs/preferences.h" ++#endif ++ + #if BUILDFLAG(IS_ANDROID) + #include "chrome/browser/accessibility/accessibility_prefs/android/accessibility_prefs_controller.h" + #include "chrome/browser/android/bookmarks/partner_bookmarks_shim.h" +@@ -1933,6 +1939,11 @@ void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry, + IncognitoModePrefs::RegisterProfilePrefs(registry); + invalidation::PerUserTopicSubscriptionManager::RegisterProfilePrefs(registry); + invalidation::InvalidatorRegistrarWithMemory::RegisterProfilePrefs(registry); ++#if BUILDFLAG(ENABLE_IPFS) ++ if (base::FeatureList::IsEnabled(ipfs::kEnableIpfs)) { ++ ipfs::RegisterPreferences(registry); ++ } ++#endif + language::LanguagePrefs::RegisterProfilePrefs(registry); + login_detection::prefs::RegisterProfilePrefs(registry); + lookalikes::RegisterProfilePrefs(registry); diff --git a/chromium_edits/133.0.6835.3/chrome/browser/shell_integration_mac.mm.patch b/chromium_edits/133.0.6835.3/chrome/browser/shell_integration_mac.mm.patch new file mode 100644 index 00000000..220e2546 --- /dev/null +++ b/chromium_edits/133.0.6835.3/chrome/browser/shell_integration_mac.mm.patch @@ -0,0 +1,13 @@ +diff --git a/chrome/browser/shell_integration_mac.mm b/chrome/browser/shell_integration_mac.mm +index c6bb768979453..c0d0abb9c78f3 100644 +--- a/chrome/browser/shell_integration_mac.mm ++++ b/chrome/browser/shell_integration_mac.mm +@@ -79,6 +79,8 @@ bool SetAsDefaultBrowser() { + if (LSSetDefaultHandlerForURLScheme(CFSTR("https"), identifier) != noErr) { + return false; + } ++ LSSetDefaultHandlerForURLScheme(CFSTR("ipfs"), identifier); ++ LSSetDefaultHandlerForURLScheme(CFSTR("ipns"), identifier); + if (LSSetDefaultRoleHandlerForContentType(kUTTypeHTML, kLSRolesViewer, + identifier) != noErr) { + return false; diff --git a/chromium_edits/133.0.6835.3/chrome/common/chrome_content_client.cc.patch b/chromium_edits/133.0.6835.3/chrome/common/chrome_content_client.cc.patch new file mode 100644 index 00000000..40bc3abe --- /dev/null +++ b/chromium_edits/133.0.6835.3/chrome/common/chrome_content_client.cc.patch @@ -0,0 +1,17 @@ +diff --git a/chrome/common/chrome_content_client.cc b/chrome/common/chrome_content_client.cc +index aa28db3f8aaa3..252958825aa2a 100644 +--- a/chrome/common/chrome_content_client.cc ++++ b/chrome/common/chrome_content_client.cc +@@ -314,6 +314,12 @@ void ChromeContentClient::AddAdditionalSchemes(Schemes* schemes) { + #if BUILDFLAG(IS_ANDROID) + schemes->local_schemes.push_back(url::kContentScheme); + #endif ++ for ( const char* ip_s : {"ipfs", "ipns"} ) { ++ schemes->standard_schemes.push_back(ip_s); ++ schemes->cors_enabled_schemes.push_back(ip_s); ++ schemes->secure_schemes.push_back(ip_s); ++ schemes->csp_bypassing_schemes.push_back(ip_s); ++ } + } + + std::u16string ChromeContentClient::GetLocalizedString(int message_id) { diff --git a/chromium_edits/133.0.6835.3/chrome/installer/linux/common/desktop.template.patch b/chromium_edits/133.0.6835.3/chrome/installer/linux/common/desktop.template.patch new file mode 100644 index 00000000..dcd9460b --- /dev/null +++ b/chromium_edits/133.0.6835.3/chrome/installer/linux/common/desktop.template.patch @@ -0,0 +1,13 @@ +diff --git a/chrome/installer/linux/common/desktop.template b/chrome/installer/linux/common/desktop.template +index 2eb13ee1aba46..9af65726bde89 100644 +--- a/chrome/installer/linux/common/desktop.template ++++ b/chrome/installer/linux/common/desktop.template +@@ -111,7 +111,7 @@ Terminal=false + Icon=@@PACKAGE@@ + Type=Application + Categories=Network;WebBrowser; +-MimeType=application/pdf;application/rdf+xml;application/rss+xml;application/xhtml+xml;application/xhtml_xml;application/xml;image/gif;image/jpeg;image/png;image/webp;text/html;text/xml;x-scheme-handler/http;x-scheme-handler/https; ++MimeType=application/pdf;application/rdf+xml;application/rss+xml;application/xhtml+xml;application/xhtml_xml;application/xml;image/gif;image/jpeg;image/png;image/webp;text/html;text/xml;x-scheme-handler/http;x-scheme-handler/https;x-scheme-handler/ipfs;x-scheme-handler/ipns; + Actions=new-window;new-private-window; + + [Desktop Action new-window] diff --git a/chromium_edits/133.0.6835.3/chrome/installer/util/shell_util.cc.patch b/chromium_edits/133.0.6835.3/chrome/installer/util/shell_util.cc.patch new file mode 100644 index 00000000..38f9123c --- /dev/null +++ b/chromium_edits/133.0.6835.3/chrome/installer/util/shell_util.cc.patch @@ -0,0 +1,20 @@ +diff --git a/chrome/installer/util/shell_util.cc b/chrome/installer/util/shell_util.cc +index 0f9ca6c1674c2..2e5c8f11b28d8 100644 +--- a/chrome/installer/util/shell_util.cc ++++ b/chrome/installer/util/shell_util.cc +@@ -1538,11 +1538,12 @@ const wchar_t* ShellUtil::kDefaultFileAssociations[] = { + const wchar_t* ShellUtil::kPotentialFileAssociations[] = { + L".htm", L".html", L".mhtml", L".pdf", L".shtml", + L".svg", L".xht", L".xhtml", L".webp", nullptr}; +-const wchar_t* ShellUtil::kBrowserProtocolAssociations[] = {L"http", L"https", +- nullptr}; ++const wchar_t* ShellUtil::kBrowserProtocolAssociations[] = { ++ L"http", L"https", L"ipfs", L"ipns", nullptr}; + const wchar_t* ShellUtil::kPotentialProtocolAssociations[] = { + L"http", L"https", L"irc", L"mailto", L"mms", L"news", L"nntp", +- L"sms", L"smsto", L"snews", L"tel", L"urn", L"webcal", nullptr}; ++ L"sms", L"smsto", L"snews", L"tel", L"urn", L"webcal", L"ipfs", ++ L"ipns", nullptr}; + const wchar_t* ShellUtil::kRegUrlProtocol = L"URL Protocol"; + const wchar_t* ShellUtil::kRegApplication = L"\\Application"; + const wchar_t* ShellUtil::kRegAppUserModelId = L"AppUserModelId"; diff --git a/chromium_edits/133.0.6835.3/components/cbor/reader.cc.patch b/chromium_edits/133.0.6835.3/components/cbor/reader.cc.patch new file mode 100644 index 00000000..de3d0b36 --- /dev/null +++ b/chromium_edits/133.0.6835.3/components/cbor/reader.cc.patch @@ -0,0 +1,44 @@ +diff --git a/components/cbor/reader.cc b/components/cbor/reader.cc +index 24d852e45f2ba..4dfec34caabd7 100644 +--- a/components/cbor/reader.cc ++++ b/components/cbor/reader.cc +@@ -22,7 +22,7 @@ + namespace cbor { + + namespace constants { +-const char kUnsupportedMajorType[] = "Unsupported major type."; ++const char kUnsupportedMajorType[] = "Unsupported major type operation."; + } + + namespace { +@@ -156,7 +156,11 @@ std::optional Reader::DecodeCompleteDataItem(const Config& config, + case Value::Type::FLOAT_VALUE: + // Floating point values also go here since they are also type 7. + return DecodeToSimpleValueOrFloat(*header, config); +- case Value::Type::TAG: // We explicitly don't support TAG. ++ case Value::Type::TAG: ++ if (config.parse_tags) { ++ return ReadTagContent(*header, config, max_nesting_level); ++ } ++ break; + case Value::Type::NONE: + case Value::Type::INVALID_UTF8: + break; +@@ -347,6 +351,17 @@ std::optional Reader::ReadByteStringContent( + return Value(std::move(cbor_byte_string)); + } + ++std::optional Reader::ReadTagContent( ++ const Reader::DataItemHeader& header, ++ const Config& config, ++ int max_nesting_level) { ++ auto tagged_content = DecodeCompleteDataItem(config, max_nesting_level); ++ if (tagged_content.has_value()) { ++ tagged_content.value().SetTag(header.value); ++ } ++ return tagged_content; ++} ++ + std::optional Reader::ReadArrayContent( + const Reader::DataItemHeader& header, + const Config& config, diff --git a/chromium_edits/133.0.6835.3/components/cbor/reader.h.patch b/chromium_edits/133.0.6835.3/components/cbor/reader.h.patch new file mode 100644 index 00000000..2dbc0534 --- /dev/null +++ b/chromium_edits/133.0.6835.3/components/cbor/reader.h.patch @@ -0,0 +1,26 @@ +diff --git a/components/cbor/reader.h b/components/cbor/reader.h +index 5f11ba48ba494..d4c9c489da4b6 100644 +--- a/components/cbor/reader.h ++++ b/components/cbor/reader.h +@@ -131,6 +131,11 @@ class CBOR_EXPORT Reader { + // during decoding will set raise the `UNSUPPORTED_FLOATING_POINT_VALUE` + // error. + bool allow_floating_point = false; ++ ++ // If the parser encounters a TAG element, should it be parsed out and ++ // the tag value saved (true), or should the entire node and its content ++ // be discarded (false) ++ bool parse_tags = false; + }; + + Reader(const Reader&) = delete; +@@ -205,6 +210,9 @@ class CBOR_EXPORT Reader { + std::optional ReadMapContent(const DataItemHeader& header, + const Config& config, + int max_nesting_level); ++ std::optional ReadTagContent(const DataItemHeader& header, ++ const Config& config, ++ int max_nesting_level); + std::optional ReadByte(); + std::optional> ReadBytes(uint64_t num_bytes); + bool IsKeyInOrder(const Value& new_key, diff --git a/chromium_edits/133.0.6835.3/components/cbor/reader_unittest.cc.patch b/chromium_edits/133.0.6835.3/components/cbor/reader_unittest.cc.patch new file mode 100644 index 00000000..150e0c73 --- /dev/null +++ b/chromium_edits/133.0.6835.3/components/cbor/reader_unittest.cc.patch @@ -0,0 +1,47 @@ +diff --git a/components/cbor/reader_unittest.cc b/components/cbor/reader_unittest.cc +index e5c02ceea3402..f26b8e77f6da3 100644 +--- a/components/cbor/reader_unittest.cc ++++ b/components/cbor/reader_unittest.cc +@@ -1449,5 +1449,42 @@ TEST(CBORReaderTest, AllowInvalidUTF8) { + EXPECT_FALSE(cbor); + EXPECT_EQ(Reader::DecoderError::INVALID_UTF8, error); + } ++TEST(CBORReaderTest, RejectsTagUnderDefaultConfig) { ++ static const uint8_t kTaggedCbor[] = { ++ 0xd8, 0x2a, 0x58, 0x25, 0x00, 0x01, 0x71, 0x12, 0x20, 0x69, 0xea, 0x07, ++ 0x40, 0xf9, 0x80, 0x7a, 0x28, 0xf4, 0xd9, 0x32, 0xc6, 0x2e, 0x7c, 0x1c, ++ 0x83, 0xbe, 0x05, 0x5e, 0x55, 0x07, 0x2c, 0x90, 0x26, 0x6a, 0xb3, 0xe7, ++ 0x9d, 0xf6, 0x3a, 0x36, 0x5b ++ }; ++ Reader::Config config; ++ auto cbor = Reader::Read(kTaggedCbor, config); ++ EXPECT_FALSE(cbor.has_value()); ++} ++TEST(CBORReaderTest, ReadsTagWhenConfiguredToDoSo) { ++ static const uint8_t kTaggedCbor[] = { ++ 0xd8, 0x2a, 0x58, 0x25, 0x00, 0x01, 0x71, 0x12, 0x20, 0x69, 0xea, 0x07, ++ 0x40, 0xf9, 0x80, 0x7a, 0x28, 0xf4, 0xd9, 0x32, 0xc6, 0x2e, 0x7c, 0x1c, ++ 0x83, 0xbe, 0x05, 0x5e, 0x55, 0x07, 0x2c, 0x90, 0x26, 0x6a, 0xb3, 0xe7, ++ 0x9d, 0xf6, 0x3a, 0x36, 0x5b ++ }; ++ Reader::Config config; ++ config.parse_tags = true; ++ auto cbor = Reader::Read(kTaggedCbor, config); ++ EXPECT_TRUE(cbor.has_value()); ++ auto& v = cbor.value(); ++ EXPECT_TRUE(v.has_tag()); ++ EXPECT_EQ(v.GetTag(),42UL); ++ EXPECT_TRUE(v.is_bytestring()); ++ EXPECT_EQ(v.type(), Value::Type::BYTE_STRING); ++ auto& bytes = v.GetBytestring(); ++ EXPECT_EQ(bytes.size(), 37UL); ++ EXPECT_EQ(bytes.at(0), 0x00);//identity multibase (e.g. not base-encoded, bytes are themselves) ++ EXPECT_EQ(bytes.at(1), 0x01);//CID version 1 ++ EXPECT_EQ(bytes.at(2), 0x71);//codec = dag-cbor ++ EXPECT_EQ(bytes.at(3), 0x12);//multihash = 18 = sha2-256 ++ EXPECT_EQ(bytes.at(4), 0x20);//hash length = 32 bytes ++ EXPECT_EQ(bytes.at(5), 0x69);//first byte of hash digest ++ EXPECT_EQ(bytes.at(36),0x5b);//last byte of hash digest ++} + + } // namespace cbor diff --git a/chromium_edits/133.0.6835.3/components/cbor/values.cc.patch b/chromium_edits/133.0.6835.3/components/cbor/values.cc.patch new file mode 100644 index 00000000..890571d8 --- /dev/null +++ b/chromium_edits/133.0.6835.3/components/cbor/values.cc.patch @@ -0,0 +1,145 @@ +diff --git a/components/cbor/values.cc b/components/cbor/values.cc +index c43c6d8265220..337ca908c813f 100644 +--- a/components/cbor/values.cc ++++ b/components/cbor/values.cc +@@ -64,32 +64,34 @@ Value::Value(Type type) : type_(type) { + NOTREACHED_IN_MIGRATION(); + } + +-Value::Value(SimpleValue in_simple) +- : type_(Type::SIMPLE_VALUE), simple_value_(in_simple) { ++Value::Value(SimpleValue in_simple, uint64_t tag) ++ : type_(Type::SIMPLE_VALUE), simple_value_(in_simple), tag_(tag) { + CHECK(static_cast(in_simple) >= 20 && static_cast(in_simple) <= 23); + } + +-Value::Value(bool boolean_value) : type_(Type::SIMPLE_VALUE) { ++Value::Value(bool boolean_value, uint64_t tag) : type_(Type::SIMPLE_VALUE), tag_(tag) { + simple_value_ = boolean_value ? Value::SimpleValue::TRUE_VALUE + : Value::SimpleValue::FALSE_VALUE; + } + +-Value::Value(double float_value) +- : type_(Type::FLOAT_VALUE), float_value_(float_value) {} ++Value::Value(double float_value, uint64_t tag) ++ : type_(Type::FLOAT_VALUE), float_value_(float_value), tag_(tag) {} + +-Value::Value(int integer_value) +- : Value(base::checked_cast(integer_value)) {} ++Value::Value(int integer_value, uint64_t tag) ++ : Value(base::checked_cast(integer_value), tag) {} + +-Value::Value(int64_t integer_value) : integer_value_(integer_value) { ++Value::Value(int64_t integer_value, uint64_t tag) : integer_value_(integer_value), tag_(tag) { + type_ = integer_value >= 0 ? Type::UNSIGNED : Type::NEGATIVE; + } + +-Value::Value(base::span in_bytes) ++Value::Value(base::span in_bytes, uint64_t tag) + : type_(Type::BYTE_STRING), +- bytestring_value_(in_bytes.begin(), in_bytes.end()) {} ++ bytestring_value_(in_bytes.begin(), in_bytes.end()), ++ tag_(tag) ++ {} + +-Value::Value(base::span in_bytes, Type type) +- : type_(type), bytestring_value_(in_bytes.begin(), in_bytes.end()) { ++Value::Value(base::span in_bytes, Type type, uint64_t tag) ++ : type_(type), bytestring_value_(in_bytes.begin(), in_bytes.end()), tag_(tag) { + DCHECK(type_ == Type::BYTE_STRING || type_ == Type::INVALID_UTF8); + } + +@@ -115,7 +117,8 @@ Value::Value(std::string&& in_string, Type type) noexcept : type_(type) { + } + } + +-Value::Value(std::string_view in_string, Type type) : type_(type) { ++Value::Value(std::string_view in_string, Type type, uint64_t tag) ++: type_(type), tag_(tag) { + switch (type_) { + case Type::STRING: + new (&string_value_) std::string(); +@@ -131,16 +134,18 @@ Value::Value(std::string_view in_string, Type type) : type_(type) { + } + } + +-Value::Value(const ArrayValue& in_array) : type_(Type::ARRAY), array_value_() { ++Value::Value(const ArrayValue& in_array, uint64_t tag) ++: type_(Type::ARRAY), array_value_(), tag_(tag) { + array_value_.reserve(in_array.size()); + for (const auto& val : in_array) + array_value_.emplace_back(val.Clone()); + } + +-Value::Value(ArrayValue&& in_array) noexcept +- : type_(Type::ARRAY), array_value_(std::move(in_array)) {} ++Value::Value(ArrayValue&& in_array, uint64_t tag) noexcept ++ : type_(Type::ARRAY), array_value_(std::move(in_array)), tag_(tag) {} + +-Value::Value(const MapValue& in_map) : type_(Type::MAP), map_value_() { ++Value::Value(const MapValue& in_map, uint64_t tag) ++: type_(Type::MAP), map_value_(), tag_(tag) { + map_value_.reserve(in_map.size()); + for (const auto& it : in_map) + map_value_.emplace_hint(map_value_.end(), it.first.Clone(), +@@ -166,31 +171,36 @@ Value Value::Clone() const { + case Type::NONE: + return Value(); + case Type::INVALID_UTF8: +- return Value(bytestring_value_, Type::INVALID_UTF8); ++ return Value(bytestring_value_, Type::INVALID_UTF8, tag_); + case Type::UNSIGNED: + case Type::NEGATIVE: +- return Value(integer_value_); ++ return Value(integer_value_, tag_); + case Type::BYTE_STRING: +- return Value(bytestring_value_); ++ return Value(bytestring_value_, tag_); + case Type::STRING: +- return Value(string_value_); ++ return Value(string_value_, Type::STRING, tag_); + case Type::ARRAY: +- return Value(array_value_); ++ return Value(array_value_, tag_); + case Type::MAP: +- return Value(map_value_); ++ return Value(map_value_, tag_); + case Type::TAG: + NOTREACHED_IN_MIGRATION() << constants::kUnsupportedMajorType; + return Value(); + case Type::SIMPLE_VALUE: +- return Value(simple_value_); ++ return Value(simple_value_, tag_); + case Type::FLOAT_VALUE: +- return Value(float_value_); ++ return Value(float_value_, tag_); + } + + NOTREACHED_IN_MIGRATION(); + return Value(); + } + ++Value& Value::SetTag(uint64_t tag) noexcept { ++ tag_ = tag; ++ return *this; ++} ++ + Value::SimpleValue Value::GetSimpleValue() const { + CHECK(is_simple()); + return simple_value_; +@@ -256,9 +266,14 @@ const Value::BinaryValue& Value::GetInvalidUTF8() const { + return bytestring_value_; + } + ++uint64_t Value::GetTag() const { ++ CHECK(has_tag()); ++ return tag_; ++} ++ + void Value::InternalMoveConstructFrom(Value&& that) { + type_ = that.type_; +- ++ tag_ = that.tag_; + switch (type_) { + case Type::UNSIGNED: + case Type::NEGATIVE: diff --git a/chromium_edits/133.0.6835.3/components/cbor/values.h.patch b/chromium_edits/133.0.6835.3/components/cbor/values.h.patch new file mode 100644 index 00000000..5556e8c5 --- /dev/null +++ b/chromium_edits/133.0.6835.3/components/cbor/values.h.patch @@ -0,0 +1,79 @@ +diff --git a/components/cbor/values.h b/components/cbor/values.h +index d55369f1a71bf..7dabb368c51d6 100644 +--- a/components/cbor/values.h ++++ b/components/cbor/values.h +@@ -125,28 +125,29 @@ class CBOR_EXPORT Value { + + explicit Value(Type type); + +- explicit Value(SimpleValue in_simple); +- explicit Value(bool boolean_value); +- explicit Value(double in_float); ++ explicit Value(SimpleValue in_simple, uint64_t tag = NO_TAG); ++ explicit Value(bool boolean_value, uint64_t tag = NO_TAG); ++ explicit Value(double in_float, uint64_t tag = NO_TAG); + +- explicit Value(int integer_value); +- explicit Value(int64_t integer_value); ++ explicit Value(int integer_value, uint64_t tag = NO_TAG); ++ explicit Value(int64_t integer_value, uint64_t tag = NO_TAG); + explicit Value(uint64_t integer_value) = delete; + +- explicit Value(base::span in_bytes); ++ explicit Value(base::span in_bytes, uint64_t tag = NO_TAG); + explicit Value(BinaryValue&& in_bytes) noexcept; + + explicit Value(const char* in_string, Type type = Type::STRING); + explicit Value(std::string&& in_string, Type type = Type::STRING) noexcept; +- explicit Value(std::string_view in_string, Type type = Type::STRING); ++ explicit Value(std::string_view in_string, Type type = Type::STRING, uint64_t tag = NO_TAG); + +- explicit Value(const ArrayValue& in_array); +- explicit Value(ArrayValue&& in_array) noexcept; ++ explicit Value(const ArrayValue& in_array, uint64_t tag = NO_TAG); ++ explicit Value(ArrayValue&& in_array, uint64_t tag = NO_TAG) noexcept; + +- explicit Value(const MapValue& in_map); ++ explicit Value(const MapValue& in_map, uint64_t tag = NO_TAG); + explicit Value(MapValue&& in_map) noexcept; + + Value& operator=(Value&& that) noexcept; ++ Value& SetTag(uint64_t) noexcept; + + Value(const Value&) = delete; + Value& operator=(const Value&) = delete; +@@ -177,6 +178,7 @@ class CBOR_EXPORT Value { + bool is_string() const { return type() == Type::STRING; } + bool is_array() const { return type() == Type::ARRAY; } + bool is_map() const { return type() == Type::MAP; } ++ bool has_tag() const { return tag_ != NO_TAG; } + + // These will all fatally assert if the type doesn't match. + SimpleValue GetSimpleValue() const; +@@ -192,12 +194,13 @@ class CBOR_EXPORT Value { + const ArrayValue& GetArray() const; + const MapValue& GetMap() const; + const BinaryValue& GetInvalidUTF8() const; ++ uint64_t GetTag() const; + + private: + friend class Reader; + // This constructor allows INVALID_UTF8 values to be created, which only + // |Reader| and InvalidUTF8StringValueForTesting() may do. +- Value(base::span in_bytes, Type type); ++ Value(base::span in_bytes, Type type, uint64_t tag = NO_TAG); + + Type type_; + +@@ -211,6 +214,11 @@ class CBOR_EXPORT Value { + MapValue map_value_; + }; + ++ //This value specified as Invalid, ++ // used here to represent absence of TAG ++ constexpr static uint64_t NO_TAG = 0xFFFF; ++ uint64_t tag_ = NO_TAG; ++ + void InternalMoveConstructFrom(Value&& that); + void InternalCleanup(); + }; diff --git a/chromium_edits/133.0.6835.3/components/cbor/writer.cc.patch b/chromium_edits/133.0.6835.3/components/cbor/writer.cc.patch new file mode 100644 index 00000000..1950e174 --- /dev/null +++ b/chromium_edits/133.0.6835.3/components/cbor/writer.cc.patch @@ -0,0 +1,14 @@ +diff --git a/components/cbor/writer.cc b/components/cbor/writer.cc +index c4bfcfb602949..b92885a30971c 100644 +--- a/components/cbor/writer.cc ++++ b/components/cbor/writer.cc +@@ -47,6 +47,9 @@ bool Writer::EncodeCBOR(const Value& node, + if (max_nesting_level < 0) + return false; + ++ if (node.has_tag()) { ++ StartItem(Value::Type::TAG, node.GetTag()); ++ } + switch (node.type()) { + case Value::Type::NONE: { + StartItem(Value::Type::BYTE_STRING, 0); diff --git a/chromium_edits/133.0.6835.3/components/cbor/writer_unittest.cc.patch b/chromium_edits/133.0.6835.3/components/cbor/writer_unittest.cc.patch new file mode 100644 index 00000000..1acf5f7f --- /dev/null +++ b/chromium_edits/133.0.6835.3/components/cbor/writer_unittest.cc.patch @@ -0,0 +1,36 @@ +diff --git a/components/cbor/writer_unittest.cc b/components/cbor/writer_unittest.cc +index ee11e7cb86712..b8942f1829a37 100644 +--- a/components/cbor/writer_unittest.cc ++++ b/components/cbor/writer_unittest.cc +@@ -523,4 +523,31 @@ TEST(CBORWriterTest, OverlyNestedCBOR) { + EXPECT_FALSE(Writer::Write(Value(map), 4).has_value()); + } + ++TEST(CBORWriterTest, CanWriteTag) { ++ std::array content{ ++ 0x00, 0x01, 0x71, 0x12, 0x20, ++ 0x69, 0xea, 0x07, 0x40, 0xf9, ++ 0x80, 0x7a, 0x28, 0xf4, 0xd9, ++ 0x32, 0xc6, 0x2e, 0x7c, 0x1c, ++ 0x83, 0xbe, 0x05, 0x5e, 0x55, ++ 0x07, 0x2c, 0x90, 0x26, 0x6a, ++ 0xb3, 0xe7, 0x9d, 0xf6, 0x3a, ++ 0x36, 0x5b ++ }; ++ Value to_write(content); ++ to_write.SetTag(42); ++ auto result = Writer::Write(to_write); ++ EXPECT_TRUE(result.has_value()); ++ auto& bytes = result.value(); ++ EXPECT_EQ(bytes.size(), 41UL); ++ EXPECT_EQ(bytes.at(0), 0xd8); ++ EXPECT_EQ(bytes.at(1), 0x2a); ++ EXPECT_EQ(bytes.at(2), 0x58); ++ EXPECT_EQ(bytes.at(3), 0x25); ++ for (auto i = 0UL; i < content.size(); ++i) { ++ ASSERT_LT(i + 4UL, bytes.size()); ++ ASSERT_EQ(content.at(i), bytes.at(i+4UL)); ++ } ++} ++ + } // namespace cbor diff --git a/chromium_edits/133.0.6835.3/components/open_from_clipboard/clipboard_recent_content_generic.cc.patch b/chromium_edits/133.0.6835.3/components/open_from_clipboard/clipboard_recent_content_generic.cc.patch new file mode 100644 index 00000000..ee376ce1 --- /dev/null +++ b/chromium_edits/133.0.6835.3/components/open_from_clipboard/clipboard_recent_content_generic.cc.patch @@ -0,0 +1,13 @@ +diff --git a/components/open_from_clipboard/clipboard_recent_content_generic.cc b/components/open_from_clipboard/clipboard_recent_content_generic.cc +index 3683fadcc0914..440d4be132e5c 100644 +--- a/components/open_from_clipboard/clipboard_recent_content_generic.cc ++++ b/components/open_from_clipboard/clipboard_recent_content_generic.cc +@@ -20,7 +20,7 @@ + namespace { + // Schemes appropriate for suggestion by ClipboardRecentContent. + const char* kAuthorizedSchemes[] = { +- url::kAboutScheme, url::kDataScheme, url::kHttpScheme, url::kHttpsScheme, ++ url::kAboutScheme, url::kDataScheme, url::kHttpScheme, url::kHttpsScheme, "ipfs", "ipns" + // TODO(mpearson): add support for chrome:// URLs. Right now the scheme + // for that lives in content and is accessible via + // GetEmbedderRepresentationOfAboutScheme() or content::kChromeUIScheme diff --git a/chromium_edits/133.0.6835.3/net/dns/dns_config_service_linux.cc.patch b/chromium_edits/133.0.6835.3/net/dns/dns_config_service_linux.cc.patch new file mode 100644 index 00000000..fd7227a5 --- /dev/null +++ b/chromium_edits/133.0.6835.3/net/dns/dns_config_service_linux.cc.patch @@ -0,0 +1,18 @@ +diff --git a/net/dns/dns_config_service_linux.cc b/net/dns/dns_config_service_linux.cc +index 7aaf9fa5b0b78..5a9f5b5a70dd9 100644 +--- a/net/dns/dns_config_service_linux.cc ++++ b/net/dns/dns_config_service_linux.cc +@@ -276,11 +276,11 @@ bool IsNsswitchConfigCompatible( + // Ignore any entries after `kDns` because Chrome will fallback to the + // system resolver if a result was not found in DNS. + return true; +- ++ case NsswitchReader::Service::kResolve: ++ break; + case NsswitchReader::Service::kMdns: + case NsswitchReader::Service::kMdns4: + case NsswitchReader::Service::kMdns6: +- case NsswitchReader::Service::kResolve: + case NsswitchReader::Service::kNis: + RecordIncompatibleNsswitchReason( + IncompatibleNsswitchReason::kIncompatibleService, diff --git a/chromium_edits/133.0.6835.3/third_party/blink/renderer/platform/weborigin/scheme_registry.cc.patch b/chromium_edits/133.0.6835.3/third_party/blink/renderer/platform/weborigin/scheme_registry.cc.patch new file mode 100644 index 00000000..663fe49e --- /dev/null +++ b/chromium_edits/133.0.6835.3/third_party/blink/renderer/platform/weborigin/scheme_registry.cc.patch @@ -0,0 +1,15 @@ +diff --git a/third_party/blink/renderer/platform/weborigin/scheme_registry.cc b/third_party/blink/renderer/platform/weborigin/scheme_registry.cc +index e1bc209c337c5..6fbac29fcddfd 100644 +--- a/third_party/blink/renderer/platform/weborigin/scheme_registry.cc ++++ b/third_party/blink/renderer/platform/weborigin/scheme_registry.cc +@@ -68,8 +68,8 @@ class URLSchemesRegistry final { + // is considered secure. Additional checks are performed to ensure that + // other http pages are filtered out. + service_worker_schemes({"http", "https"}), +- fetch_api_schemes({"http", "https"}), +- allowed_in_referrer_schemes({"http", "https"}) { ++ fetch_api_schemes({"http", "https", "ipfs", "ipns"}), ++ allowed_in_referrer_schemes({"http", "https", "ipfs", "ipns"}) { + for (auto& scheme : url::GetCorsEnabledSchemes()) + cors_enabled_schemes.insert(scheme.c_str()); + for (auto& scheme : url::GetCSPBypassingSchemes()) { diff --git a/chromium_edits/133.0.6835.3/url/BUILD.gn.patch b/chromium_edits/133.0.6835.3/url/BUILD.gn.patch new file mode 100644 index 00000000..be4bfca8 --- /dev/null +++ b/chromium_edits/133.0.6835.3/url/BUILD.gn.patch @@ -0,0 +1,32 @@ +diff --git a/url/BUILD.gn b/url/BUILD.gn +index f22b73bc29f06..df36977322ec7 100644 +--- a/url/BUILD.gn ++++ b/url/BUILD.gn +@@ -5,6 +5,7 @@ + import("//build/buildflag_header.gni") + import("//testing/libfuzzer/fuzzer_test.gni") + import("//testing/test.gni") ++import("//third_party/ipfs_client/args.gni") + import("features.gni") + + import("//build/config/cronet/config.gni") +@@ -67,6 +68,7 @@ component("url") { + public_deps = [ + "//base", + "//build:robolectric_buildflags", ++ "//third_party/ipfs_client:ipfs_buildflags", + ] + + configs += [ "//build/config/compiler:wexit_time_destructors" ] +@@ -89,6 +91,11 @@ component("url") { + public_configs = [ "//third_party/jdk" ] + } + ++ if (enable_ipfs) { ++ sources += [ "url_canon_ipfs.cc" ] ++ deps += [ "//third_party/ipfs_client:ipfs_client" ] ++ } ++ + if (is_win) { + # Don't conflict with Windows' "url.dll". + output_name = "url_lib" diff --git a/chromium_edits/133.0.6835.3/url/url_canon.h.patch b/chromium_edits/133.0.6835.3/url/url_canon.h.patch new file mode 100644 index 00000000..dbe10d9e --- /dev/null +++ b/chromium_edits/133.0.6835.3/url/url_canon.h.patch @@ -0,0 +1,26 @@ +diff --git a/url/url_canon.h b/url/url_canon.h +index 99e5ef40de5fd..a08834f62c3cc 100644 +--- a/url/url_canon.h ++++ b/url/url_canon.h +@@ -854,6 +854,21 @@ bool CanonicalizeMailtoURL(const char16_t* spec, + CanonOutput* output, + Parsed* new_parsed); + ++COMPONENT_EXPORT(URL) ++bool CanonicalizeIpfsURL(std::string_view spec, ++ const Parsed& parsed, ++ SchemeType scheme_type, ++ CharsetConverter* query_converter, ++ CanonOutput* output, ++ Parsed* new_parsed); ++COMPONENT_EXPORT(URL) ++bool CanonicalizeIpfsURL(std::basic_string_view spec, ++ const Parsed& parsed, ++ SchemeType scheme_type, ++ CharsetConverter* query_converter, ++ CanonOutput* output, ++ Parsed* new_parsed); ++ + // Part replacer -------------------------------------------------------------- + + // Internal structure used for storing separate strings for each component. diff --git a/chromium_edits/133.0.6835.3/url/url_canon_ipfs.cc b/chromium_edits/133.0.6835.3/url/url_canon_ipfs.cc new file mode 100644 index 00000000..e40732ee --- /dev/null +++ b/chromium_edits/133.0.6835.3/url/url_canon_ipfs.cc @@ -0,0 +1,54 @@ +#include "url_canon_internal.h" + +#include +#include + +#include + +bool url::CanonicalizeIpfsURL(std::string_view spec, + const Parsed& parsed, + SchemeType scheme_type, + CharsetConverter* charset_converter, + CanonOutput* output, + Parsed* output_parsed) { + if (spec.size() < 1) { + return false; + } + if ( parsed.host.len < 1 ) { + return false; + } + auto cid_str = spec.substr( parsed.host.begin, static_cast(parsed.host.len) ); + auto cid = ipfs::Cid(cid_str); + if ( !cid.valid() ) { + cid = ipfs::id_cid::forText( std::string{cid_str} + " is not a valid CID." ); + } + auto as_str = cid.to_string(); + if ( as_str.empty() ) { + return false; + } + std::string stdurl{ spec.substr(0UL, static_cast(parsed.host.begin)) }; + stdurl.append( as_str ); + spec.remove_prefix(parsed.host.end()); + stdurl.append(spec); + auto len = static_cast(stdurl.size()); + Parsed parsed_input; + ParseStandardURL(stdurl.data(), len, &parsed_input); + return CanonicalizeStandardURL( + stdurl.data(), + parsed_input, + scheme_type, + charset_converter, + output, output_parsed + ); +} +bool url::CanonicalizeIpfsURL(std::basic_string_view spec, + const Parsed& parsed, + SchemeType scheme_type, + CharsetConverter* query_converter, + CanonOutput* output, + Parsed* new_parsed) { + RawCanonOutput<2048> as8; + ConvertUTF16ToUTF8(spec.data(), spec.size(), &as8); + return CanonicalizeIpfsURL({as8.data(), as8.length()}, parsed, scheme_type, + query_converter, output, new_parsed); +} diff --git a/chromium_edits/133.0.6835.3/url/url_util.cc.patch b/chromium_edits/133.0.6835.3/url/url_util.cc.patch new file mode 100644 index 00000000..8d22ec10 --- /dev/null +++ b/chromium_edits/133.0.6835.3/url/url_util.cc.patch @@ -0,0 +1,45 @@ +diff --git a/url/url_util.cc b/url/url_util.cc +index 67c4c5f3ce124..b268390940561 100644 +--- a/url/url_util.cc ++++ b/url/url_util.cc +@@ -76,6 +76,8 @@ struct SchemeRegistry { + std::vector referrer_schemes = { + {kHttpsScheme, SCHEME_WITH_HOST_PORT_AND_USER_INFORMATION}, + {kHttpScheme, SCHEME_WITH_HOST_PORT_AND_USER_INFORMATION}, ++ {"ipfs", SCHEME_WITH_HOST}, ++ {"ipns", SCHEME_WITH_HOST}, + }; + + // Schemes that do not trigger mixed content warning. +@@ -84,6 +86,8 @@ struct SchemeRegistry { + kWssScheme, + kDataScheme, + kAboutScheme, ++ {"ipfs", SCHEME_WITH_HOST}, ++ {"ipns", SCHEME_WITH_HOST}, + }; + + // Schemes that normal pages cannot link to or access (i.e., with the same +@@ -105,6 +109,8 @@ struct SchemeRegistry { + kHttpsScheme, + kHttpScheme, + kDataScheme, ++ {"ipfs", SCHEME_WITH_HOST}, ++ {"ipns", SCHEME_WITH_HOST}, + }; + + // Schemes that can be used by web to store data (local storage, etc). +@@ -308,7 +314,12 @@ bool DoCanonicalize(const CHAR* spec, + success = CanonicalizeFileSystemURL( + spec, ParseFileSystemURL(std::basic_string_view(spec, spec_len)), + charset_converter, output, output_parsed); +- ++ } else if (DoCompareSchemeComponent(spec, scheme, "ipfs")) { ++ auto spec_view = std::basic_string_view(spec, spec_len); ++ // Switch multibase away from case-sensitive ones before continuing canonicalization. ++ auto parsed_input = ParseStandardURL(spec_view); ++ success = CanonicalizeIpfsURL(spec_view, parsed_input, scheme_type, ++ charset_converter, output, output_parsed); + } else if (DoIsStandard(spec, scheme, &scheme_type)) { + // All "normal" URLs. + success = CanonicalizeStandardURL( diff --git a/cmake/patch.py b/cmake/patch.py index bfa69f85..49903429 100755 --- a/cmake/patch.py +++ b/cmake/patch.py @@ -23,13 +23,13 @@ try: import requests -except Exception as ex: +except ModuleNotFoundError as ex: check_call([executable, "-m", "pip", "install", "requests"]) import requests verbose('Installed requests because of', ex) -VERSION_CLOSE_ENOUGH = 30122 +VERSION_CLOSE_ENOUGH = 30123 LARGE_INT = 9876543210 here = dirname(__file__) @@ -42,10 +42,10 @@ def osname() -> str: return "Windows" -def as_int(v): +def as_int(ver_str): result = 0 try: - for c in v.split("."): + for c in ver_str.split("."): result *= 10000 result += int(c) except ValueError: @@ -61,13 +61,9 @@ def closest_by_version(needle, haystack): def content_differs(ap, bp): if not isfile(ap) or not isfile(bp): return True - with open(ap) as a: - with open(bp) as b: - try: - return a.read() != b.read() - except Exception as e: - print(f"Error diffing {ap} against {bp}: {e}", file=stderr) - sys.exit(7) + with open(ap, encoding="utf-8") as a: + with open(bp, encoding="utf-8") as b: + return a.read() != b.read() class Result(Enum): @@ -125,7 +121,7 @@ def create_patch_file(self): to_path += ".rm" print("Remembering the removal of", from_path, "with", to_path) os.makedirs(to_dir, exist_ok=True) - with open(to_path, "w") as rm_f: + with open(to_path, "w", encoding='utf-8') as rm_f: rm_f.write( "//Remember to remove the corresponding file from the Chromium source tree" ) @@ -134,7 +130,7 @@ def create_patch_file(self): if diff_out: os.makedirs(to_dir, exist_ok=True) to_path += ".patch" - with open(to_path, "w") as to_f: + with open(to_path, "w", encoding='utf-8') as to_f: to_f.write(diff_out) print(to_path) self.git(["add", "url/url_canon_ipfs.cc"], Result.OrDie) @@ -168,7 +164,7 @@ def apply(self): rel = relpath(edit, edits_dir) to_path = join(self.csrc, rel) if ext == ".patch": - self.check_patch(edit, rel, to_path) + self.check_patch(edit, rel) elif ext == ".rm": if isfile(to_path): print("Remove", to_path, "due to", edit) @@ -197,7 +193,7 @@ def edit_evidence(text: str): return True return False - def check_patch(self, patch_path: str, relative: str, target_path: str): + def check_patch(self, patch_path: str, relative: str): if 0 == self.git( ["apply", "--check", "--reverse", "--verbose", patch_path], Result.ExitCodeOnly, @@ -210,7 +206,7 @@ def check_patch(self, patch_path: str, relative: str, target_path: str): if ec == 0: print("Patched", src, "with", patch_path) else: - with open(join(self.csrc, src)) as target_file: + with open(join(self.csrc, src), encoding='utf-8') as target_file: text = target_file.read() if self.edit_evidence(text): print( @@ -273,11 +269,11 @@ def recommend(self) -> str: for channel in channels: print("Considering channel", channel, file=stderr) versions = self.release_versions(channel) - for when, version in versions: - verbose(f"Found a release version: '{version}' from {ctime(when)}") - dist, cand = closest_by_version(version, avail) + for when, rel_ver in versions: + verbose(f"Found a release version: '{rel_ver}' from {ctime(when)}") + dist, cand = closest_by_version(rel_ver, avail) if dist < win_dist: - t = f"Suggesting {cand} which is {dist} close to {version} which was {channel} @ {ctime(when)}" + t = f"Suggesting {cand} which is {dist} close to {rel_ver} which was {channel} @ {ctime(when)}" print(t, file=stderr) win_dist = dist win_cand = cand @@ -318,7 +314,7 @@ def release_versions(self, channel, pfrm=None): resp = requests.get(url=chrom_url, params=parms, timeout=999) result = list(map(lambda x: (x["time"] / 1000, x["version"]), resp.json())) elec_url = "https://raw.githubusercontent.com/electron/electron/main/DEPS" - resp = requests.get(url=elec_url) + resp = requests.get(url=elec_url, timeout=999) result.sort(reverse=True) self.up_rels[key] = result return result @@ -355,20 +351,19 @@ def oldest(self): return self.most("Extended", ["Mac", "Windows"], 0) def recent_electron_branch_version(self): - with open(join(here, "recent-electron.txt")) as revf: + with open(join(here, "recent-electron.txt"), encoding="utf-8") as revf: return int(revf.read()) def set_recent_electron_branch_version(self, v): - with open(join(here, "recent-electron.txt"), "w") as revf: + with open(join(here, "recent-electron.txt"), "w", encoding="utf-8") as revf: revf.write(str(v)) call([self.gbin, "add", join("cmake", "recent-electron.txt")]) def electron_version(self, branch="main"): if f"electron-{branch}" in self.up_rels: return self.up_rels[f"electron-{branch}"] - resp = requests.get( - f"https://raw.githubusercontent.com/electron/electron/{branch}/DEPS" - ) + u = f"https://raw.githubusercontent.com/electron/electron/{branch}/DEPS" + resp = requests.get(u, timeout=999) toks = resp.text.split("'") i = toks.index("chromium_version") + 2 self.up_rels[f"electron-{branch}"] = toks[i] @@ -384,7 +379,6 @@ def electron_versions(self): rebv = ev except ValueError as e: verbose("Couldn't get next, possibly-nonexistent, electron version's chromium version.", e, type(e)) - pass result = {} for i in range(-2, 1): ev = i + rebv @@ -437,7 +431,7 @@ def out_of_date(self, p): file_path = join(dir_path, "components/cbor/reader_unittest.cc.patch") if not isfile(file_path): return True - with open(file_path) as f: + with open(file_path, encoding="utf-8") as f: lines = list(map(lambda x: x.strip(), f.readlines())) if ( "+ absl::optional cbor = Reader::Read(kTaggedCbor, config);" @@ -449,7 +443,7 @@ def out_of_date(self, p): if not isfile(file_path): verbose('No patching of', file_path) return True - with open(file_path) as f: + with open(file_path, encoding="utf-8") as f: lines = list(map(lambda x: x.strip(), f.readlines())) if not any(map(lambda x: 'x-scheme-handler/ipfs' in x, lines)): verbose(p, "No ipfs scheme in Linux installer", file_path) @@ -457,7 +451,7 @@ def out_of_date(self, p): file_path = f"{self.pdir}/{p}.patch" if not isfile(file_path): return False - with open(file_path) as f: + with open(file_path, encoding="utf-8") as f: lines = list(map(lambda x: x.strip(), f.readlines())) if not Patcher.has_file_line( lines, @@ -476,9 +470,9 @@ def out_of_date(self, p): return False @staticmethod - def has_file_line(lines: list[str], path: str, line: str): + def has_file_line(lines: list[str], path: str, line_txt: str): fl = Patcher.file_lines(lines, path) - return (line + "\n") in fl + return (line_txt + "\n") in fl @staticmethod def file_lines(lines: list[str], path): @@ -497,10 +491,10 @@ def list_ood(self, to_check: list[str], sense: bool, both: bool = False): oldest = self.oldest() newest = self.newest() gap = newest[0] - oldest[0] + VERSION_CLOSE_ENOUGH - min = oldest[0] - gap + min_ver = oldest[0] - gap min_date = time() - 3600 * 24 * 31 * 6 verbose( - f"Oldest supportable version: {oldest} , newest was: {newest} , gap: {gap} -> {min}" + f"Oldest supportable version: {oldest} , newest was: {newest} , gap: {gap} -> {min_ver}" ) for p in to_check: d = self.date_of(p) @@ -508,8 +502,8 @@ def list_ood(self, to_check: list[str], sense: bool, both: bool = False): if self.out_of_date(p): verbose(p, "failed compatibility checks") is_ood = True - elif d < min_date and as_int(p) < min: - verbose(d, "<", min_date, "and", as_int(p), "<", min) + elif d < min_date and as_int(p) < min_ver: + verbose(d, "<", min_date, "and", as_int(p), "<", min_ver) is_ood = True else: is_ood = False @@ -541,8 +535,8 @@ def list_ood(self, to_check: list[str], sense: bool, both: bool = False): for chan in ["Dev", "Beta", "Stable", "Extended"]: for osn in ["Linux", "Mac", "Windows"]: rels = per.release_versions(chan, osn) - for (n,v) in zip(['Cur', 'Prv', 'Old'], rels): - print(f"{v[1]:15} {n} {chan:9}{os:7}") + for (step_desc,verinf) in zip(['Cur', 'Prv', 'Old'], rels): + print(f"{verinf[1]:15} {step_desc} {chan:9}{os:7}") for (elec_br,chrom_ver) in per.electron_versions().items(): print(f"{chrom_ver:15} Electron {elec_br}") print(f"{per.electron_version():15} Electron main") @@ -573,13 +567,13 @@ def list_ood(self, to_check: list[str], sense: bool, both: bool = False): pr = Patcher(realpath(join(dirname(__file__), "..")), "git", "Debug") PREFIX = "?? component/patches/" SUFFIX = "patch" - for line in pr.git(["status", "--porcelain"], Result.RawOutput).splitlines(): - if line.startswith(PREFIX) and line.endswith(SUFFIX): - end = len(line) - len(SUFFIX) - 1 - pch = line[len(PREFIX): end] + for output_line in pr.git(["status", "--porcelain"], Result.RawOutput).splitlines(): + if output_line.startswith(PREFIX) and output_line.endswith(SUFFIX): + end = len(output_line) - len(SUFFIX) - 1 + pch = output_line[len(PREFIX): end] if pr.out_of_date(pch): sys.exit(9) else: - pr.git(["add", line[3:]], Result.OrDie) + pr.git(["add", output_line[3:]], Result.OrDie) else: Patcher(*argv[1:4]).create_patch_file() diff --git a/cmake/pylint_thresh.py b/cmake/pylint_thresh.py index 8ee8300c..bc9be907 100644 --- a/cmake/pylint_thresh.py +++ b/cmake/pylint_thresh.py @@ -5,7 +5,7 @@ from re import sub from sys import argv -THRESHOLD = 7.7 +THRESHOLD = 7.9 def msg_out(msg): f = msg["path"] @@ -16,8 +16,9 @@ def msg_out(msg): t = msg["type"] print(f"{f}:{l}:{c}: {t}: {i} {m}") -if __name__ == "__main__": - with open(argv[1]) as f: + +def parse(warn_file: str): + with open(warn_file, encoding="utf-8") as f: o = load(f) msgs = o['messages'] for warn in list(filter(lambda x:x['type']=='warning', msgs))[0:9]: @@ -31,6 +32,9 @@ def msg_out(msg): elif score > THRESHOLD + 0.3: update = (score + THRESHOLD) / 2 print("Increasing threshold to", update) - s = open(__file__).read() + s = open(__file__, encoding="utf-8").read() s = sub(r'\n\s*THRESHOLD\s*=\s*\d*\.\d*\s*\n', f"\n\nTHRESHOLD = {update:.2}\n\n", s) - open(__file__, 'w').write(s) + open(__file__, 'w', encoding="utf-8").write(s) + +if __name__ == "__main__": + parse(argv[1]) diff --git a/cmake/release.py b/cmake/release.py index e73b9fb6..5b140fb8 100755 --- a/cmake/release.py +++ b/cmake/release.py @@ -63,9 +63,9 @@ def line_to_var(line): return ('', None) -vars = check_output(['cmake', '-L', '-N', '-B', '.'], text=True).splitlines() -vars = dict(map(line_to_var, vars)) -chromium_out = join(vars['CHROMIUM_SOURCE_TREE'], 'out', vars['CHROMIUM_PROFILE']) +cmak_vars = check_output(['cmake', '-L', '-N', '-B', '.'], text=True).splitlines() +cmak_vars = dict(map(line_to_var, cmak_vars)) +chromium_out = join(cmak_vars['CHROMIUM_SOURCE_TREE'], 'out', cmak_vars['CHROMIUM_PROFILE']) tok = environ.get('GITHUB_TOKEN') if tok: gh = GhApi() @@ -95,10 +95,7 @@ def upload(contains): for ext in artifact_extensions: if f.endswith(ext): print('Uploading', f, 'to', GITHUB_ORG, GITHUB_REPO, 'release', version) - try: - gh.upload_file(gh_rel, f) - except Exception as e: - print(' ... Error uploading ', f, ':', e) + gh.upload_file(gh_rel, f) break diff --git a/library/include/ipfs_client/gw/gateway_request.h b/library/include/ipfs_client/gw/gateway_request.h index 51f56813..dd69f69c 100644 --- a/library/include/ipfs_client/gw/gateway_request.h +++ b/library/include/ipfs_client/gw/gateway_request.h @@ -44,6 +44,7 @@ class GatewayRequest : public std::enable_shared_from_this { std::function; private: + std::optional cid_; std::shared_ptr orchestrator_; std::vector bytes_received_hooks; std::string main_param; ///< CID, IPNS name, hostname @@ -66,11 +67,12 @@ class GatewayRequest : public std::enable_shared_from_this { // TODO - encapsulate. Hopefully these public data members aren't directly accessed everywhere std::string path; ///< For CAR requests std::shared_ptr dependent; - std::optional cid; short parallel = 0; std::string affinity; std::unordered_set failures; + std::optional const& cid() const; + void cid(Cid c); std::string url_suffix() const; std::string_view accept() const; std::string_view identity_data() const; diff --git a/library/src/ipfs_client/ctx/default_gateways.cc b/library/src/ipfs_client/ctx/default_gateways.cc index 0d5eeaf6..4880ebdf 100644 --- a/library/src/ipfs_client/ctx/default_gateways.cc +++ b/library/src/ipfs_client/ctx/default_gateways.cc @@ -33,24 +33,24 @@ auto ctx::LoadGatewaysFromEnvironmentVariable(ipfs::ctx::GatewayConfig& cfg) -> // NOLINTBEGIN(readability-magic-numbers) void ctx::LoadStaticGatewayList(ipfs::ctx::GatewayConfig& cfg) { auto static_list = { - std::pair{"http://127.0.0.1:8080/", 1043}, - {"https://ipfs.io/", 1001}, - {"https://dweb.link/", 941}, - {"https://trustless-gateway.link/", 938}, - {"https://hardbin.com/", 910}, - {"https://ipfs.greyh.at/", 858}, - {"https://ipfs.joaoleitao.org/", 848}, - {"https://dlunar.net/", 689}, - {"https://flk-ipfs.io/", 675}, - {"https://ipfs.cyou/", 471}, - {"https://human.mypinata.cloud/", 412}, - {"https://jcsl.hopto.org/", 363}, - {"https://delegated-ipfs.dev/", 318}, - {"https://4everland.io/", 297}, - {"https://ipfs.runfission.com/", 262}, - {"https://gateway.pinata.cloud/", 141}, - {"https://dag.w3s.link/", 135}, - {"https://flk-ipfs.xyz/", 104}, + std::pair{"http://127.0.0.1:8080/", 1044}, + {"https://ipfs.io/", 997}, + {"https://dweb.link/", 938}, + {"https://trustless-gateway.link/", 935}, + {"https://hardbin.com/", 905}, + {"https://ipfs.greyh.at/", 855}, + {"https://ipfs.joaoleitao.org/", 843}, + {"https://dlunar.net/", 684}, + {"https://flk-ipfs.io/", 669}, + {"https://ipfs.cyou/", 467}, + {"https://human.mypinata.cloud/", 409}, + {"https://jcsl.hopto.org/", 355}, + {"https://delegated-ipfs.dev/", 312}, + {"https://4everland.io/", 294}, + {"https://ipfs.runfission.com/", 256}, + {"https://gateway.pinata.cloud/", 137}, + {"https://dag.w3s.link/", 131}, + {"https://flk-ipfs.xyz/", 109}, {"https://ipfs.eth.aragon.network/", 11}, {"https://data.filstorage.io/", 10}, {"https://storry.tv/", 9}, diff --git a/library/src/ipfs_client/gw/gateway_request.cc b/library/src/ipfs_client/gw/gateway_request.cc index 6b402c6a..5a40a168 100644 --- a/library/src/ipfs_client/gw/gateway_request.cc +++ b/library/src/ipfs_client/gw/gateway_request.cc @@ -37,19 +37,14 @@ auto Self::fromIpfsPath(ipfs::SlashDelimited ipfs_path) -> std::shared_ptr auto name_space = ipfs_path.pop(); auto r = std::make_shared(); r->main_param = ipfs_path.pop(); - Cid cid(r->main_param); - if (cid.valid()) { - r->cid = std::move(cid); - } else { - r->cid = std::nullopt; - } + r->cid(Cid{r->main_param}); if (name_space == "ipfs") { - if (!r->cid.has_value()) { + if (!r->cid().has_value()) { LOG(ERROR) << "IPFS request with invalid/unsupported CID " << r->main_param; return {}; } - if (r->cid.value().hash_type() == HashType::IDENTITY) { + if (r->cid().value().hash_type() == HashType::IDENTITY) { r->type = GatewayRequestType::Identity; } else { r->path = ipfs_path.pop_all(); @@ -137,8 +132,8 @@ auto Self::identity_data() const -> std::string_view { if (type != GatewayRequestType::Identity) { return ""; } - auto hash = cid.value().hash(); - const auto *d = reinterpret_cast(hash.data()); + auto hash = cid_.value().hash(); + char const* d = reinterpret_cast(hash.data()); return std::string_view{d, hash.size()}; } @@ -276,7 +271,7 @@ auto Self::RespondSuccessfully(std::string_view bytes, if (c.valid()) { VLOG(1) << debug_string() << " resolves to " << c.to_string(); AddDnsLink("/ipfs/" + c.to_string(), success, src); - cid = c; + cid(c); AddBlock(bytes, success, src, api, valid); } else { AddDnsLink(bytes, success, src); @@ -345,8 +340,8 @@ auto Self::Finished() const -> bool { return false; } void Self::FleshOut(ipld::BlockSource& s) const { - if (cid.has_value() && cid->valid()) { - s.cid = cid->to_string(); + if (cid().has_value() && cid()->valid()) { + s.cid = cid()->to_string(); } else { s.cid = main_param; } @@ -368,14 +363,14 @@ void Self::AddBlock(std::string_view bytes, ipld::BlockSource src, std::shared_ptr const& api, bool* valid) { - DCHECK(cid.has_value()); - if (!cid.has_value()) { + DCHECK(cid().has_value()); + if (!cid().has_value()) { LOG(ERROR) << "Your CID doesn't even have a value!"; success = false; return; } DCHECK(api); - auto node = ipld::DagNode::fromBytes(api, cid.value(), bytes); + auto node = ipld::DagNode::fromBytes(api, cid().value(), bytes); if (!node) { success = false; } else { @@ -409,9 +404,9 @@ void Self::AddBlocks(Car& car, const std::shared_ptr& api, bool& success } } auto Self::IpnsResponse(ByteView bytes, std::shared_ptr const& api, bool& success, bool* valid, ipld::BlockSource src) -> bool { - if (cid.has_value()) { + if (cid().has_value()) { DCHECK(api); - auto rec = ipfs::ValidateIpnsRecord(bytes, cid.value(), *api); + auto rec = ipfs::ValidateIpnsRecord(bytes, cid().value(), *api); if (rec.has_value()) { ValidatedIpns const validated{rec.value()}; auto node = std::make_shared(validated); @@ -430,3 +425,14 @@ auto Self::IpnsResponse(ByteView bytes, std::shared_ptr const& api, bool } return true; } + +auto Self::cid() const -> std::optional const& { + return cid_; +} +void Self::cid(Cid cid) { + if (cid.valid()) { + cid_ = cid; + } else { + cid_ = {}; + } +} diff --git a/library/src/ipfs_client/gw/gateway_request_unittest.cc b/library/src/ipfs_client/gw/gateway_request_unittest.cc index 9c7637d0..5f393e64 100644 --- a/library/src/ipfs_client/gw/gateway_request_unittest.cc +++ b/library/src/ipfs_client/gw/gateway_request_unittest.cc @@ -71,8 +71,7 @@ struct GatewayRequestTest : public testing::Test { TEST_F(GatewayRequestTest, RespondsToCar) { LogRecorder lr; - t_.cid = - i::Cid{"bafybeibwfakyszctcz54dungqay7jae35agjjhokltvvtboospgo6napxy"}; + t_.cid(i::Cid{"bafybeibwfakyszctcz54dungqay7jae35agjjhokltvvtboospgo6napxy"}); t_.type = RT::Car; auto p = reinterpret_cast(a_car.data()); EXPECT_FALSE(orc->has_key( diff --git a/library/src/ipfs_client/gw/gateway_state.cc b/library/src/ipfs_client/gw/gateway_state.cc index 4caaca8b..7bac9aaa 100644 --- a/library/src/ipfs_client/gw/gateway_state.cc +++ b/library/src/ipfs_client/gw/gateway_state.cc @@ -60,7 +60,7 @@ void Self::hit(GatewayRequestType grt, GatewayRequest const& req) { config.SetTypeAffinity(prefix_, grt, std::max(typaff + 9, 1)); affinity_success[req.affinity] += 9; auto rpm = config.GetGatewayRate(prefix_); - for (auto i = 10; i != 0; --i) { + for (auto i = 12; i != 0; --i) { if (over_rate(++rpm / i)) { ++rpm; } else { diff --git a/library/src/ipfs_client/gw/inline_request_handler_unittest.cc b/library/src/ipfs_client/gw/inline_request_handler_unittest.cc index 43813dba..c8599d03 100644 --- a/library/src/ipfs_client/gw/inline_request_handler_unittest.cc +++ b/library/src/ipfs_client/gw/inline_request_handler_unittest.cc @@ -27,7 +27,7 @@ TEST(InlineRequestHanlder, bluesky) { r->type = RT::Identity; r->orchestrator(orc); i::MultiHash h(i::HashType::IDENTITY, i::as_bytes("abc"sv)); - r->cid = Cid(i::MultiCodec::RAW, h); + r->cid({i::MultiCodec::RAW, h}); auto res = t.handle(r); EXPECT_EQ(static_cast(res), 'D'); }