1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
|
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "components/navigation_interception/intercept_navigation_throttle.h"
#include "components/navigation_interception/navigation_params.h"
#include "content/public/browser/browser_thread.h"
#include "content/public/browser/navigation_handle.h"
using content::BrowserThread;
namespace navigation_interception {
namespace {
using ChecksPerformedCallback = base::Callback<void(bool, bool)>;
// This is used to run |should_ignore_callback| if it can destroy the
// WebContents (and the InterceptNavigationThrottle along). In that case,
// |on_checks_performed_callback| will be a no-op.
void RunCallback(
content::WebContents* web_contents,
const NavigationParams& navigation_params,
InterceptNavigationThrottle::CheckCallback should_ignore_callback,
ChecksPerformedCallback on_checks_performed_callback,
base::WeakPtr<InterceptNavigationThrottle> throttle) {
bool should_ignore_navigation =
should_ignore_callback.Run(web_contents, navigation_params);
// If the InterceptNavigationThrottle that called RunCallback is still alive
// after |should_ignore_callback| has run, this will run
// InterceptNavigationThrottle::OnAsynchronousChecksPerformed.
// TODO(clamy): remove this boolean after crbug.com/570200 is fixed.
bool throttle_was_destroyed = !throttle.get();
on_checks_performed_callback.Run(should_ignore_navigation,
throttle_was_destroyed);
}
} // namespace
InterceptNavigationThrottle::InterceptNavigationThrottle(
content::NavigationHandle* navigation_handle,
CheckCallback should_ignore_callback,
bool run_callback_synchronously)
: content::NavigationThrottle(navigation_handle),
should_ignore_callback_(should_ignore_callback),
run_callback_synchronously_(run_callback_synchronously),
weak_factory_(this) {}
InterceptNavigationThrottle::~InterceptNavigationThrottle() {}
content::NavigationThrottle::ThrottleCheckResult
InterceptNavigationThrottle::WillStartRequest() {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
return CheckIfShouldIgnoreNavigation(false);
}
content::NavigationThrottle::ThrottleCheckResult
InterceptNavigationThrottle::WillRedirectRequest() {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
return CheckIfShouldIgnoreNavigation(true);
}
content::NavigationThrottle::ThrottleCheckResult
InterceptNavigationThrottle::CheckIfShouldIgnoreNavigation(bool is_redirect) {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
NavigationParams navigation_params(
navigation_handle()->GetURL(), navigation_handle()->GetReferrer(),
navigation_handle()->HasUserGesture(), navigation_handle()->IsPost(),
navigation_handle()->GetPageTransition(), is_redirect,
navigation_handle()->IsExternalProtocol(), true);
if (run_callback_synchronously_) {
bool should_ignore_navigation = should_ignore_callback_.Run(
navigation_handle()->GetWebContents(), navigation_params);
return should_ignore_navigation
? content::NavigationThrottle::CANCEL_AND_IGNORE
: content::NavigationThrottle::PROCEED;
}
// When the callback can potentially destroy the WebContents, along with the
// NavigationHandle and this InterceptNavigationThrottle, it should be run
// asynchronously. This will ensure that no objects on the stack can be
// deleted, and that the stack does not unwind through them in a deleted
// state.
BrowserThread::PostTask(
BrowserThread::UI, FROM_HERE,
base::Bind(&InterceptNavigationThrottle::RunCallbackAsynchronously,
weak_factory_.GetWeakPtr(), navigation_params));
return DEFER;
}
void InterceptNavigationThrottle::RunCallbackAsynchronously(
const NavigationParams& navigation_params) {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
// Run the callback in a helper function as it may lead ot the destruction of
// this InterceptNavigationThrottle.
RunCallback(
navigation_handle()->GetWebContents(), navigation_params,
should_ignore_callback_,
base::Bind(&InterceptNavigationThrottle::OnAsynchronousChecksPerformed,
weak_factory_.GetWeakPtr()),
weak_factory_.GetWeakPtr());
// DO NOT ADD CODE AFTER HERE: at this point the InterceptNavigationThrottle
// may have been destroyed by the |should_ignore_callback_|. Adding code here
// will cause use-after-free bugs.
//
// Code that needs to act on the result of the |should_ignore_callback_|
// should be put inside OnAsynchronousChecksPerformed. This function will be
// called after |should_ignore_callback_| has run, if this
// InterceptNavigationThrottle is still alive.
}
void InterceptNavigationThrottle::OnAsynchronousChecksPerformed(
bool should_ignore_navigation,
bool throttle_was_destroyed) {
CHECK(!throttle_was_destroyed);
content::NavigationHandle* handle = navigation_handle();
CHECK(handle);
if (should_ignore_navigation) {
navigation_handle()->CancelDeferredNavigation(
content::NavigationThrottle::CANCEL_AND_IGNORE);
} else {
handle->Resume();
}
}
} // namespace navigation_interception
|
