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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
|
// Copyright (c) 2012 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 "base/json/json_string_value_serializer.h"
#include "chrome/browser/net/predictor.h"
#include "chrome/browser/prefs/pref_service.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/browser/ui/browser.h"
#include "chrome/common/pref_names.h"
#include "chrome/test/base/in_process_browser_test.h"
#include "chrome/test/base/ui_test_utils.h"
#include "net/base/host_resolver_proc.h"
#include "net/base/mock_host_resolver.h"
#include "net/base/net_errors.h"
#include "testing/gmock/include/gmock/gmock.h"
using content::BrowserThread;
using testing::HasSubstr;
namespace {
// Records a history of all hostnames for which resolving has been requested,
// and immediately fails the resolution requests themselves.
class HostResolutionRequestRecorder : public net::HostResolverProc {
public:
HostResolutionRequestRecorder()
: HostResolverProc(NULL),
is_waiting_for_hostname_(false) {
}
virtual int Resolve(const std::string& host,
net::AddressFamily address_family,
net::HostResolverFlags host_resolver_flags,
net::AddressList* addrlist,
int* os_error) OVERRIDE {
BrowserThread::PostTask(
BrowserThread::UI,
FROM_HERE,
base::Bind(&HostResolutionRequestRecorder::AddToHistory,
base::Unretained(this),
host));
return net::ERR_NAME_NOT_RESOLVED;
}
bool HasHostBeenRequested(const std::string& hostname) {
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
return std::find(requested_hostnames_.begin(),
requested_hostnames_.end(),
hostname) != requested_hostnames_.end();
}
void WaitUntilHostHasBeenRequested(const std::string& hostname) {
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
DCHECK(!is_waiting_for_hostname_);
if (HasHostBeenRequested(hostname))
return;
waiting_for_hostname_ = hostname;
is_waiting_for_hostname_ = true;
content::RunMessageLoop();
}
private:
virtual ~HostResolutionRequestRecorder() {}
void AddToHistory(const std::string& hostname) {
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
requested_hostnames_.push_back(hostname);
if (is_waiting_for_hostname_ && waiting_for_hostname_ == hostname) {
is_waiting_for_hostname_ = false;
waiting_for_hostname_.clear();
MessageLoop::current()->Quit();
}
}
// The hostname which WaitUntilHostHasBeenRequested is currently waiting for
// to be requested.
std::string waiting_for_hostname_;
// Whether WaitUntilHostHasBeenRequested is waiting for a hostname to be
// requested and thus is running a nested message loop.
bool is_waiting_for_hostname_;
// A list of hostnames for which resolution has already been requested. Only
// to be accessed from the UI thread.
std::vector<std::string> requested_hostnames_;
DISALLOW_COPY_AND_ASSIGN(HostResolutionRequestRecorder);
};
} // namespace
namespace chrome_browser_net {
class PredictorBrowserTest : public InProcessBrowserTest {
public:
PredictorBrowserTest()
: startup_url_("http://host1:1"),
referring_url_("http://host2:1"),
target_url_("http://host3:1"),
host_resolution_request_recorder_(new HostResolutionRequestRecorder) {
}
protected:
virtual void SetUp() OVERRIDE {
net::ScopedDefaultHostResolverProc scoped_host_resolver_proc(
host_resolution_request_recorder_);
InProcessBrowserTest::SetUp();
}
void LearnAboutInitialNavigation(const GURL& url) {
Predictor* predictor = browser()->profile()->GetNetworkPredictor();
BrowserThread::PostTask(BrowserThread::IO,
FROM_HERE,
base::Bind(&Predictor::LearnAboutInitialNavigation,
base::Unretained(predictor),
url));
content::RunAllPendingInMessageLoop(BrowserThread::IO);
}
void LearnFromNavigation(const GURL& referring_url, const GURL& target_url) {
Predictor* predictor = browser()->profile()->GetNetworkPredictor();
BrowserThread::PostTask(BrowserThread::IO,
FROM_HERE,
base::Bind(&Predictor::LearnFromNavigation,
base::Unretained(predictor),
referring_url,
target_url));
content::RunAllPendingInMessageLoop(BrowserThread::IO);
}
void PrepareFrameSubresources(const GURL& url) {
Predictor* predictor = browser()->profile()->GetNetworkPredictor();
predictor->PredictFrameSubresources(url);
}
void GetListFromPrefsAsString(const char* list_path,
std::string* value_as_string) const {
PrefService* prefs = browser()->profile()->GetPrefs();
const base::ListValue* list_value = prefs->GetList(list_path);
JSONStringValueSerializer serializer(value_as_string);
serializer.Serialize(*list_value);
}
void WaitUntilHostHasBeenRequested(const std::string& hostname) {
host_resolution_request_recorder_->WaitUntilHostHasBeenRequested(hostname);
}
const GURL startup_url_;
const GURL referring_url_;
const GURL target_url_;
private:
scoped_refptr<HostResolutionRequestRecorder>
host_resolution_request_recorder_;
};
IN_PROC_BROWSER_TEST_F(PredictorBrowserTest, PRE_ShutdownStartupCycle) {
// Prepare state that will be serialized on this shut-down and read on next
// start-up.
LearnAboutInitialNavigation(startup_url_);
LearnFromNavigation(referring_url_, target_url_);
}
IN_PROC_BROWSER_TEST_F(PredictorBrowserTest, ShutdownStartupCycle) {
// Make sure that the Preferences file is actually wiped of all DNS prefetch
// related data after start-up.
std::string cleared_startup_list;
std::string cleared_referral_list;
GetListFromPrefsAsString(prefs::kDnsPrefetchingStartupList,
&cleared_startup_list);
GetListFromPrefsAsString(prefs::kDnsPrefetchingHostReferralList,
&cleared_referral_list);
EXPECT_THAT(cleared_startup_list, Not(HasSubstr(startup_url_.host())));
EXPECT_THAT(cleared_referral_list, Not(HasSubstr(referring_url_.host())));
EXPECT_THAT(cleared_referral_list, Not(HasSubstr(target_url_.host())));
// But also make sure this data has been first loaded into the Predictor, by
// inspecting that the Predictor starts making the expected hostname requests.
PrepareFrameSubresources(referring_url_);
WaitUntilHostHasBeenRequested(startup_url_.host());
WaitUntilHostHasBeenRequested(target_url_.host());
}
} // namespace chrome_browser_net
|
