OLD | NEW |
1 // Copyright (c) 2017 The Chromium Authors. All rights reserved. | 1 // Copyright 2017 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "components/subresource_filter/content/browser/subresource_filter_safe_
browsing_activation_throttle.h" | 5 #include "components/subresource_filter/content/browser/subresource_filter_safe_
browsing_activation_throttle.h" |
6 | 6 |
| 7 #include <utility> |
7 #include <vector> | 8 #include <vector> |
8 | 9 |
| 10 #include "base/metrics/histogram_macros.h" |
9 #include "base/timer/timer.h" | 11 #include "base/timer/timer.h" |
10 #include "components/safe_browsing_db/v4_local_database_manager.h" | |
11 #include "components/subresource_filter/content/browser/content_subresource_filt
er_driver_factory.h" | 12 #include "components/subresource_filter/content/browser/content_subresource_filt
er_driver_factory.h" |
| 13 #include "components/subresource_filter/content/browser/subresource_filter_safe_
browsing_client.h" |
12 #include "content/public/browser/browser_thread.h" | 14 #include "content/public/browser/browser_thread.h" |
13 #include "content/public/browser/navigation_handle.h" | 15 #include "content/public/browser/navigation_handle.h" |
14 #include "content/public/browser/web_contents.h" | 16 #include "content/public/browser/web_contents.h" |
15 | 17 |
16 namespace { | |
17 | |
18 // Maximum time in milliseconds to wait for the Safe Browsing service to | |
19 // verify a URL. After this amount of time the outstanding check will be | |
20 // aborted, and the URL will be treated as if it didn't belong to the | |
21 // Subresource Filter only list. | |
22 constexpr base::TimeDelta kCheckURLTimeout = base::TimeDelta::FromSeconds(5); | |
23 | |
24 } // namespace | |
25 | |
26 namespace subresource_filter { | 18 namespace subresource_filter { |
27 | 19 |
28 class SubresourceFilterSafeBrowsingActivationThrottle::SBDatabaseClient | |
29 : public safe_browsing::SafeBrowsingDatabaseManager::Client { | |
30 public: | |
31 SBDatabaseClient( | |
32 scoped_refptr<safe_browsing::SafeBrowsingDatabaseManager> | |
33 database_manager, | |
34 base::WeakPtr<SubresourceFilterSafeBrowsingActivationThrottle> throttle, | |
35 scoped_refptr<base::SingleThreadTaskRunner> io_task_runner) | |
36 : database_manager_(std::move(database_manager)), | |
37 throttle_(throttle), | |
38 io_task_runner_(io_task_runner) {} | |
39 | |
40 ~SBDatabaseClient() override { | |
41 DCHECK_CURRENTLY_ON(content::BrowserThread::IO); | |
42 database_manager_->CancelCheck(this); | |
43 } | |
44 | |
45 void CheckUrlOnIO(const GURL& url) { | |
46 DCHECK_CURRENTLY_ON(content::BrowserThread::IO); | |
47 DCHECK(!url.is_empty()); | |
48 url_being_checked_ = url; | |
49 if (database_manager_->CheckUrlForSubresourceFilter(url, this)) { | |
50 OnCheckBrowseUrlResult(url, safe_browsing::SB_THREAT_TYPE_SAFE, | |
51 safe_browsing::ThreatMetadata()); | |
52 return; | |
53 } | |
54 timer_.Start(FROM_HERE, kCheckURLTimeout, this, | |
55 &SubresourceFilterSafeBrowsingActivationThrottle:: | |
56 SBDatabaseClient::OnCheckUrlTimeout); | |
57 } | |
58 | |
59 void OnCheckBrowseUrlResult( | |
60 const GURL& url, | |
61 safe_browsing::SBThreatType threat_type, | |
62 const safe_browsing::ThreatMetadata& metadata) override { | |
63 DCHECK_CURRENTLY_ON(content::BrowserThread::IO); | |
64 DCHECK_EQ(url_being_checked_, url); | |
65 timer_.Stop(); // Cancel the timeout timer. | |
66 io_task_runner_->PostTask( | |
67 FROM_HERE, | |
68 base::Bind(&SubresourceFilterSafeBrowsingActivationThrottle:: | |
69 OnCheckUrlResultOnUI, | |
70 throttle_, url, threat_type, metadata.threat_pattern_type)); | |
71 } | |
72 | |
73 // Callback for when the safe browsing check has taken longer than | |
74 // kCheckURLTimeout. | |
75 void OnCheckUrlTimeout() { | |
76 DCHECK_CURRENTLY_ON(content::BrowserThread::IO); | |
77 database_manager_->CancelCheck(this); | |
78 | |
79 OnCheckBrowseUrlResult(url_being_checked_, | |
80 safe_browsing::SB_THREAT_TYPE_SAFE, | |
81 safe_browsing::ThreatMetadata()); | |
82 } | |
83 | |
84 private: | |
85 scoped_refptr<safe_browsing::SafeBrowsingDatabaseManager> database_manager_; | |
86 | |
87 // Timer to abort the safe browsing check if it takes too long. | |
88 base::OneShotTimer timer_; | |
89 GURL url_being_checked_; | |
90 | |
91 base::WeakPtr<SubresourceFilterSafeBrowsingActivationThrottle> throttle_; | |
92 scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_; | |
93 | |
94 DISALLOW_COPY_AND_ASSIGN(SBDatabaseClient); | |
95 }; | |
96 | |
97 SubresourceFilterSafeBrowsingActivationThrottle:: | 20 SubresourceFilterSafeBrowsingActivationThrottle:: |
98 SubresourceFilterSafeBrowsingActivationThrottle( | 21 SubresourceFilterSafeBrowsingActivationThrottle( |
99 content::NavigationHandle* handle, | 22 content::NavigationHandle* handle, |
| 23 scoped_refptr<base::SingleThreadTaskRunner> io_task_runner, |
100 scoped_refptr<safe_browsing::SafeBrowsingDatabaseManager> | 24 scoped_refptr<safe_browsing::SafeBrowsingDatabaseManager> |
101 database_manager) | 25 database_manager) |
102 : NavigationThrottle(handle), | 26 : NavigationThrottle(handle), |
103 io_task_runner_(content::BrowserThread::GetTaskRunnerForThread( | 27 database_manager_(std::move(database_manager)), |
104 content::BrowserThread::IO)), | 28 io_task_runner_(io_task_runner), |
105 database_client_( | 29 database_client_(new SubresourceFilterSafeBrowsingClient( |
106 new SubresourceFilterSafeBrowsingActivationThrottle::SBDatabaseClient( | 30 database_manager_, |
107 std::move(database_manager), | 31 AsWeakPtr(), |
108 AsWeakPtr(), | 32 io_task_runner, |
109 base::ThreadTaskRunnerHandle::Get()), | 33 base::ThreadTaskRunnerHandle::Get()), |
110 base::OnTaskRunnerDeleter(io_task_runner_)) {} | 34 base::OnTaskRunnerDeleter(io_task_runner_)) {} |
111 | 35 |
112 SubresourceFilterSafeBrowsingActivationThrottle:: | 36 SubresourceFilterSafeBrowsingActivationThrottle:: |
113 ~SubresourceFilterSafeBrowsingActivationThrottle() {} | 37 ~SubresourceFilterSafeBrowsingActivationThrottle() { |
| 38 // TODO(csharrison): Log metrics based on check_results_. |
| 39 } |
| 40 |
| 41 content::NavigationThrottle::ThrottleCheckResult |
| 42 SubresourceFilterSafeBrowsingActivationThrottle::WillStartRequest() { |
| 43 CheckCurrentUrl(); |
| 44 return content::NavigationThrottle::ThrottleCheckResult::PROCEED; |
| 45 } |
| 46 |
| 47 content::NavigationThrottle::ThrottleCheckResult |
| 48 SubresourceFilterSafeBrowsingActivationThrottle::WillRedirectRequest() { |
| 49 CheckCurrentUrl(); |
| 50 return content::NavigationThrottle::ThrottleCheckResult::PROCEED; |
| 51 } |
114 | 52 |
115 content::NavigationThrottle::ThrottleCheckResult | 53 content::NavigationThrottle::ThrottleCheckResult |
116 SubresourceFilterSafeBrowsingActivationThrottle::WillProcessResponse() { | 54 SubresourceFilterSafeBrowsingActivationThrottle::WillProcessResponse() { |
117 io_task_runner_->PostTask( | 55 // No need to defer the navigation if the check already happened. |
118 FROM_HERE, base::Bind(&SubresourceFilterSafeBrowsingActivationThrottle:: | 56 if (check_results_.back().finished) { |
119 SBDatabaseClient::CheckUrlOnIO, | 57 NotifyResult(); |
120 base::Unretained(database_client_.get()), | 58 return content::NavigationThrottle::ThrottleCheckResult::PROCEED; |
121 navigation_handle()->GetURL())); | 59 } |
| 60 defer_time_ = base::TimeTicks::Now(); |
122 return content::NavigationThrottle::ThrottleCheckResult::DEFER; | 61 return content::NavigationThrottle::ThrottleCheckResult::DEFER; |
123 } | 62 } |
124 | 63 |
125 const char* | 64 const char* |
126 SubresourceFilterSafeBrowsingActivationThrottle::GetNameForLogging() { | 65 SubresourceFilterSafeBrowsingActivationThrottle::GetNameForLogging() { |
127 return "SubresourceFilterSafeBrowsingActivationThrottle"; | 66 return "SubresourceFilterSafeBrowsingActivationThrottle"; |
128 } | 67 } |
129 | 68 |
130 void SubresourceFilterSafeBrowsingActivationThrottle::OnCheckUrlResultOnUI( | 69 void SubresourceFilterSafeBrowsingActivationThrottle::OnCheckUrlResultOnUI( |
131 const GURL& url, | 70 const SubresourceFilterSafeBrowsingClient::CheckResult& result) { |
132 safe_browsing::SBThreatType threat_type, | 71 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); |
133 safe_browsing::ThreatPatternType pattern_type) { | 72 size_t request_id = result.request_id; |
| 73 DCHECK_LT(request_id, check_results_.size()); |
| 74 |
| 75 auto& stored_result = check_results_.at(request_id); |
| 76 DCHECK(!stored_result.finished); |
| 77 stored_result = result; |
| 78 if (!defer_time_.is_null() && request_id == check_results_.size() - 1) { |
| 79 NotifyResult(); |
| 80 navigation_handle()->Resume(); |
| 81 } |
| 82 } |
| 83 |
| 84 void SubresourceFilterSafeBrowsingActivationThrottle::CheckCurrentUrl() { |
| 85 check_results_.emplace_back(); |
| 86 size_t id = check_results_.size() - 1; |
| 87 io_task_runner_->PostTask( |
| 88 FROM_HERE, base::Bind(&SubresourceFilterSafeBrowsingClient::CheckUrlOnIO, |
| 89 base::Unretained(database_client_.get()), |
| 90 navigation_handle()->GetURL(), id)); |
| 91 } |
| 92 |
| 93 void SubresourceFilterSafeBrowsingActivationThrottle::NotifyResult() { |
134 content::WebContents* web_contents = navigation_handle()->GetWebContents(); | 94 content::WebContents* web_contents = navigation_handle()->GetWebContents(); |
135 if (web_contents) { | 95 if (!web_contents) |
136 using subresource_filter::ContentSubresourceFilterDriverFactory; | 96 return; |
137 ContentSubresourceFilterDriverFactory* driver_factory = | |
138 ContentSubresourceFilterDriverFactory::FromWebContents(web_contents); | |
139 DCHECK(driver_factory); | |
140 | 97 |
141 driver_factory->OnMainResourceMatchedSafeBrowsingBlacklist( | 98 using subresource_filter::ContentSubresourceFilterDriverFactory; |
142 url, std::vector<GURL>(), threat_type, pattern_type); | 99 |
143 } | 100 const SubresourceFilterSafeBrowsingClient::CheckResult& result = |
144 // TODO(https://crbug.com/704508): We should measure the delay introduces by | 101 check_results_.back(); |
145 // this check. Similarly, as it's done the Safe Browsing Resource throttle. | 102 ContentSubresourceFilterDriverFactory* driver_factory = |
146 navigation_handle()->Resume(); | 103 ContentSubresourceFilterDriverFactory::FromWebContents(web_contents); |
| 104 DCHECK(driver_factory); |
| 105 |
| 106 driver_factory->OnMainResourceMatchedSafeBrowsingBlacklist( |
| 107 navigation_handle()->GetURL(), std::vector<GURL>(), result.threat_type, |
| 108 result.pattern_type); |
| 109 |
| 110 base::TimeDelta delay = defer_time_.is_null() |
| 111 ? base::TimeDelta::FromMilliseconds(0) |
| 112 : base::TimeTicks::Now() - defer_time_; |
| 113 UMA_HISTOGRAM_TIMES("SubresourceFilter.PageLoad.SafeBrowsingDelay", delay); |
| 114 |
| 115 // Log a histogram for the delay we would have introduced if the throttle only |
| 116 // speculatively checks URLs on WillStartRequest. This is only different from |
| 117 // the actual delay if there was at least one redirect. |
| 118 base::TimeDelta no_redirect_speculation_delay = |
| 119 check_results_.size() > 1 ? result.check_time : delay; |
| 120 UMA_HISTOGRAM_TIMES( |
| 121 "SubresourceFilter.PageLoad.SafeBrowsingDelay.NoRedirectSpeculation", |
| 122 no_redirect_speculation_delay); |
147 } | 123 } |
148 | 124 |
149 } // namespace subresource_filter | 125 } // namespace subresource_filter |
OLD | NEW |