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
|
// Copyright (c) 2011 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 "chrome/browser/net/connect_interceptor.h"
#include "chrome/browser/net/predictor.h"
#include "net/base/load_flags.h"
#include "net/url_request/url_request.h"
namespace chrome_browser_net {
// We don't bother learning to preconnect via a GET if the original URL
// navigation was so long ago, that a preconnection would have been dropped
// anyway. We believe most servers will drop the connection in 10 seconds, so
// we currently estimate this time-till-drop at 10 seconds.
// TODO(jar): We should do a persistent field trial to validate/optimize this.
static const int kMaxUnusedSocketLifetimeSecondsWithoutAGet = 10;
ConnectInterceptor::ConnectInterceptor(Predictor* predictor)
: timed_cache_(base::TimeDelta::FromSeconds(
kMaxUnusedSocketLifetimeSecondsWithoutAGet)),
predictor_(predictor) {
DCHECK(predictor);
}
ConnectInterceptor::~ConnectInterceptor() {
}
net::URLRequestJob* ConnectInterceptor::MaybeIntercept(
net::URLRequest* request) const {
GURL request_scheme_host(Predictor::CanonicalizeUrl(request->url()));
if (request_scheme_host == GURL::EmptyGURL())
return NULL;
// Learn what URLs are likely to be needed during next startup.
predictor_->LearnAboutInitialNavigation(request_scheme_host);
bool redirected_host = false;
if (request->referrer().empty()) {
if (request->url() != request->original_url()) {
// This request was completed with a redirect.
GURL original_scheme_host(request->original_url().GetWithEmptyPath());
if (request_scheme_host != original_scheme_host) {
redirected_host = true;
// Don't learn from redirects that take path as an argument, but do
// learn from short-hand typing entries, such as "cnn.com" redirects to
// "www.cnn.com". We can't just check for has_path(), as a mere "/"
// will count as a path, so we check that the path is at most a "/"
// (1 character long) to decide the redirect is "definitive" and has no
// significant path.
// TODO(jar): It may be ok to learn from all redirects, as the adaptive
// system will not respond until several identical redirects have taken
// place. Hence a use of a path (that changes) wouldn't really be
// learned from anyway.
if (request->original_url().path().length() <= 1 &&
timed_cache_.WasRecentlySeen(original_scheme_host)) {
// TODO(jar): These definite redirects could be learned much faster.
predictor_->LearnFromNavigation(original_scheme_host,
request_scheme_host);
}
}
}
} else {
GURL referring_scheme_host = GURL(request->referrer()).GetWithEmptyPath();
bool is_subresource = !(request->load_flags() & net::LOAD_MAIN_FRAME);
// Learn about our referring URL, for use in the future.
if (is_subresource && timed_cache_.WasRecentlySeen(referring_scheme_host))
predictor_->LearnFromNavigation(referring_scheme_host,
request_scheme_host);
if (referring_scheme_host == request_scheme_host) {
// We've already made any/all predictions when we navigated to the
// referring host, so we can bail out here.
// We don't update the RecentlySeen() time because any preconnections
// need to be made at the first navigation (i.e., when referer was loaded)
// and wouldn't have waited for this current request navigation.
return NULL;
}
}
timed_cache_.SetRecentlySeen(request_scheme_host);
// Subresources for main frames usually get predicted when we detected the
// main frame request - way back in RenderViewHost::Navigate. So only handle
// predictions now for subresources or for redirected hosts.
if ((request->load_flags() & net::LOAD_SUB_FRAME) || redirected_host)
predictor_->PredictFrameSubresources(request_scheme_host);
return NULL;
}
net::URLRequestJob* ConnectInterceptor::MaybeInterceptResponse(
net::URLRequest* request) const {
return NULL;
}
net::URLRequestJob* ConnectInterceptor::MaybeInterceptRedirect(
const GURL& location,
net::URLRequest* request) const {
return NULL;
}
ConnectInterceptor::TimedCache::TimedCache(const base::TimeDelta& max_duration)
: mru_cache_(UrlMruTimedCache::NO_AUTO_EVICT),
max_duration_(max_duration) {
}
// Make Clang compilation happy with explicit destructor.
ConnectInterceptor::TimedCache::~TimedCache() {}
bool ConnectInterceptor::TimedCache::WasRecentlySeen(const GURL& url) const {
DCHECK_EQ(url.GetWithEmptyPath(), url);
// Evict any overly old entries.
base::TimeTicks now = base::TimeTicks::Now();
UrlMruTimedCache::reverse_iterator eldest = mru_cache_.rbegin();
while (!mru_cache_.empty()) {
DCHECK(eldest == mru_cache_.rbegin());
if (now - eldest->second < max_duration_)
break;
eldest = mru_cache_.Erase(eldest);
}
return mru_cache_.end() != mru_cache_.Peek(url);
}
void ConnectInterceptor::TimedCache::SetRecentlySeen(const GURL& url) const {
DCHECK_EQ(url.GetWithEmptyPath(), url);
mru_cache_.Put(url, base::TimeTicks::Now());
}
} // namespace chrome_browser_net
|
