From 414fe95dec0477c8528f5026efe2a13abc5cda1f Mon Sep 17 00:00:00 2001 From: Mark Pilgrim Date: Wed, 7 Nov 2018 15:58:37 -0500 Subject: [PATCH] Disable domain reliability service Fixes https://github.com/brave/brave-browser/issues/1734 --- .../domain_reliability_unittest.cc | 233 ++++++++++++++++++ ...onents-domain_reliability-service.cc.patch | 12 + test/BUILD.gn | 3 + 3 files changed, 248 insertions(+) create mode 100644 components/domain_reliability/domain_reliability_unittest.cc create mode 100644 patches/components-domain_reliability-service.cc.patch diff --git a/components/domain_reliability/domain_reliability_unittest.cc b/components/domain_reliability/domain_reliability_unittest.cc new file mode 100644 index 000000000000..b382755eee23 --- /dev/null +++ b/components/domain_reliability/domain_reliability_unittest.cc @@ -0,0 +1,233 @@ +#include "components/domain_reliability/service.h" + +#include "base/logging.h" +#include "base/run_loop.h" +#include "base/single_thread_task_runner.h" +#include "base/task/post_task.h" +#include "base/test/test_simple_task_runner.h" +#include "base/time/time.h" +#include "components/domain_reliability/monitor.h" +#include "components/domain_reliability/test_util.h" +#include "content/public/browser/browser_task_traits.h" +#include "content/public/browser/browser_thread.h" +#include "content/public/browser/permission_controller.h" +#include "content/public/browser/permission_controller_delegate.h" +#include "content/public/browser/web_contents.h" +#include "content/public/test/test_browser_context.h" +#include "content/public/test/test_browser_thread_bundle.h" +#include "content/public/test/test_utils.h" +#include "net/base/host_port_pair.h" +#include "net/url_request/url_request_context_getter.h" +#include "net/url_request/url_request_test_util.h" +#include "testing/gtest/include/gtest/gtest.h" +#include "third_party/blink/public/platform/modules/permissions/permission_status.mojom.h" + +namespace domain_reliability { + +namespace { + +class TestPermissionManager : public content::PermissionControllerDelegate { + public: + TestPermissionManager() : get_permission_status_count_(0) {} + + int get_permission_status_count() const { + return get_permission_status_count_; + } + content::PermissionType last_permission() const { return last_permission_; } + const GURL& last_requesting_origin() const { return last_requesting_origin_; } + const GURL& last_embedding_origin() const { return last_embedding_origin_; } + + void set_permission_status(blink::mojom::PermissionStatus permission_status) { + permission_status_ = permission_status; + } + + // content::PermissionManager: + + ~TestPermissionManager() override {} + + blink::mojom::PermissionStatus GetPermissionStatus( + content::PermissionType permission, + const GURL& requesting_origin, + const GURL& embedding_origin) override { + ++get_permission_status_count_; + + last_permission_ = permission; + last_requesting_origin_ = requesting_origin; + last_embedding_origin_ = embedding_origin; + + return permission_status_; + } + + blink::mojom::PermissionStatus GetPermissionStatusForFrame( + content::PermissionType permission, + content::RenderFrameHost* render_frame_host, + const GURL& requesting_origin) override { + return GetPermissionStatus( + permission, requesting_origin, + content::WebContents::FromRenderFrameHost(render_frame_host) + ->GetLastCommittedURL() + .GetOrigin()); + } + + int RequestPermission( + content::PermissionType permission, + content::RenderFrameHost* render_frame_host, + const GURL& requesting_origin, + bool user_gesture, + const base::Callback& callback) + override { + NOTIMPLEMENTED(); + return content::PermissionController::kNoPendingOperation; + } + + int RequestPermissions( + const std::vector& permission, + content::RenderFrameHost* render_frame_host, + const GURL& requesting_origin, + bool user_gesture, + const base::Callback< + void(const std::vector&)>& callback) + override { + NOTIMPLEMENTED(); + return content::PermissionController::kNoPendingOperation; + } + + void ResetPermission(content::PermissionType permission, + const GURL& requesting_origin, + const GURL& embedding_origin) override { + NOTIMPLEMENTED(); + } + + int SubscribePermissionStatusChange( + content::PermissionType permission, + content::RenderFrameHost* render_frame_host, + const GURL& requesting_origin, + const base::Callback& callback) + override { + NOTIMPLEMENTED(); + return 0; + } + + void UnsubscribePermissionStatusChange(int subscription_id) override { + NOTIMPLEMENTED(); + } + + private: + // Number of calls made to GetPermissionStatus. + int get_permission_status_count_; + + // Parameters to last call to GetPermissionStatus: + + content::PermissionType last_permission_; + GURL last_requesting_origin_; + GURL last_embedding_origin_; + + // Value to return from GetPermissionStatus. + blink::mojom::PermissionStatus permission_status_; + + DISALLOW_COPY_AND_ASSIGN(TestPermissionManager); +}; + +} // namespace + +class DomainReliabilityServiceTest : public testing::Test { + protected: + using RequestInfo = DomainReliabilityMonitor::RequestInfo; + + DomainReliabilityServiceTest() + : upload_reporter_string_("test"), + permission_manager_(new TestPermissionManager()) { + scoped_refptr ui_task_runner = + base::CreateSingleThreadTaskRunnerWithTraits( + {content::BrowserThread::UI}); + scoped_refptr network_task_runner = + base::CreateSingleThreadTaskRunnerWithTraits( + {content::BrowserThread::IO}); + url_request_context_getter_ = + new net::TestURLRequestContextGetter(network_task_runner); + browser_context_.SetPermissionControllerDelegate( + base::WrapUnique(permission_manager_)); + service_ = base::WrapUnique(DomainReliabilityService::Create( + upload_reporter_string_, &browser_context_)); + monitor_ = service_->CreateMonitor(ui_task_runner, network_task_runner); + monitor_->MoveToNetworkThread(); + // Let the NetworkConnectionTracker registration complete. + thread_bundle_.RunUntilIdle(); + monitor_->InitURLRequestContext(url_request_context_getter_); + monitor_->SetDiscardUploads(true); + } + + ~DomainReliabilityServiceTest() override { + if (monitor_) + monitor_->Shutdown(); + } + + void OnRequestLegComplete(RequestInfo request) { + monitor_->OnRequestLegComplete(request); + } + + int GetDiscardedUploadCount() const { + return monitor_->uploader_->GetDiscardedUploadCount(); + } + + content::TestBrowserThreadBundle thread_bundle_; + + std::string upload_reporter_string_; + + content::TestBrowserContext browser_context_; + + // Owned by browser_context_, not the test class. + TestPermissionManager* permission_manager_; + + std::unique_ptr service_; + + scoped_refptr url_request_context_getter_; + + std::unique_ptr monitor_; + + private: + DISALLOW_COPY_AND_ASSIGN(DomainReliabilityServiceTest); +}; + +namespace { + +TEST_F(DomainReliabilityServiceTest, Create) {} + +TEST_F(DomainReliabilityServiceTest, NoFetch) { + // explicitly grant permission + permission_manager_->set_permission_status( + blink::mojom::PermissionStatus::GRANTED); + + monitor_->AddContextForTesting( + MakeTestConfigWithOrigin(GURL("https://example/"))); + + RequestInfo request; + request.status = + net::URLRequestStatus::FromError(net::ERR_CONNECTION_REFUSED); + request.response_info.socket_address = + net::HostPortPair::FromString("1.2.3.4"); + request.url = GURL("https://example/"); + request.response_info.was_cached = false; + request.response_info.network_accessed = true; + request.response_info.was_fetched_via_proxy = false; + request.load_flags = 0; + request.load_timing_info.request_start = base::TimeTicks::Now(); + request.upload_depth = 0; + + OnRequestLegComplete(request); + + // upload all pending logs + monitor_->ForceUploadsForTesting(); + + content::RunAllPendingInMessageLoop(content::BrowserThread::UI); + // confirm that we asked for permission + EXPECT_EQ(1, permission_manager_->get_permission_status_count()); + + content::RunAllPendingInMessageLoop(content::BrowserThread::IO); + // confirm that, despite having permission, no upload occurred + EXPECT_EQ(0, GetDiscardedUploadCount()); +} + +} // namespace + +} // namespace domain_reliability diff --git a/patches/components-domain_reliability-service.cc.patch b/patches/components-domain_reliability-service.cc.patch new file mode 100644 index 000000000000..077ceca2683e --- /dev/null +++ b/patches/components-domain_reliability-service.cc.patch @@ -0,0 +1,12 @@ +diff --git a/components/domain_reliability/service.cc b/components/domain_reliability/service.cc +index cf8287f98976..19c9dd11f725 100644 +--- a/components/domain_reliability/service.cc ++++ b/components/domain_reliability/service.cc +@@ -157,6 +157,7 @@ class DomainReliabilityServiceImpl : public DomainReliabilityService { + bool allowed = permission_controller->GetPermissionStatus( + content::PermissionType::BACKGROUND_SYNC, origin, + origin) == blink::mojom::PermissionStatus::GRANTED; ++ allowed = false; // feature disabled in Brave + network_task_runner->PostTask(FROM_HERE, + base::BindOnce(std::move(callback), allowed)); + } diff --git a/test/BUILD.gn b/test/BUILD.gn index 2c1db6c25f86..06d38f8f82ee 100644 --- a/test/BUILD.gn +++ b/test/BUILD.gn @@ -64,6 +64,7 @@ test("brave_unit_tests") { "//brave/components/brave_sync/brave_sync_service_unittest.cc", "//brave/components/brave_sync/client/bookmark_change_processor_unittest.cc", "//brave/components/brave_webtorrent/browser/net/brave_torrent_redirect_network_delegate_helper_unittest.cc", + "//brave/components/domain_reliability/domain_reliability_unittest.cc", "//brave/components/gcm_driver/gcm_unittest.cc", "//brave/components/spellcheck/spellcheck_unittest.cc", "//brave/third_party/libaddressinput/chromium/chrome_metadata_source_unittest.cc", @@ -73,6 +74,8 @@ test("brave_unit_tests") { "../utility/importer/chrome_importer_unittest.cc", "../utility/importer/brave_importer_unittest.cc", "../utility/importer/firefox_importer_unittest.cc", + "../../components/domain_reliability/test_util.cc", + "../../components/domain_reliability/test_util.h", ] if (brave_rewards_enabled) {