1 // Copyright 2013 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "content/renderer/media/android/media_info_loader.h"
6
7 #include "base/bits.h"
8 #include "base/callback_helpers.h"
9 #include "base/metrics/histogram.h"
10 #include "third_party/WebKit/public/platform/WebURLError.h"
11 #include "third_party/WebKit/public/platform/WebURLLoader.h"
12 #include "third_party/WebKit/public/platform/WebURLResponse.h"
13 #include "third_party/WebKit/public/web/WebFrame.h"
14
15 using blink::WebFrame;
16 using blink::WebURLError;
17 using blink::WebURLLoader;
18 using blink::WebURLLoaderOptions;
19 using blink::WebURLRequest;
20 using blink::WebURLResponse;
21
22 namespace content {
23
24 static const int kHttpOK = 200;
25
MediaInfoLoader(const GURL & url,blink::WebMediaPlayer::CORSMode cors_mode,const ReadyCB & ready_cb)26 MediaInfoLoader::MediaInfoLoader(
27 const GURL& url,
28 blink::WebMediaPlayer::CORSMode cors_mode,
29 const ReadyCB& ready_cb)
30 : loader_failed_(false),
31 url_(url),
32 allow_stored_credentials_(false),
33 cors_mode_(cors_mode),
34 single_origin_(true),
35 ready_cb_(ready_cb) {}
36
~MediaInfoLoader()37 MediaInfoLoader::~MediaInfoLoader() {}
38
Start(blink::WebFrame * frame)39 void MediaInfoLoader::Start(blink::WebFrame* frame) {
40 // Make sure we have not started.
41 DCHECK(!ready_cb_.is_null());
42 CHECK(frame);
43
44 start_time_ = base::TimeTicks::Now();
45 first_party_url_ = frame->document().firstPartyForCookies();
46
47 // Prepare the request.
48 WebURLRequest request(url_);
49 request.setTargetType(WebURLRequest::TargetIsMedia);
50 frame->setReferrerForRequest(request, blink::WebURL());
51
52 scoped_ptr<WebURLLoader> loader;
53 if (test_loader_) {
54 loader = test_loader_.Pass();
55 } else {
56 WebURLLoaderOptions options;
57 if (cors_mode_ == blink::WebMediaPlayer::CORSModeUnspecified) {
58 options.allowCredentials = true;
59 options.crossOriginRequestPolicy =
60 WebURLLoaderOptions::CrossOriginRequestPolicyAllow;
61 allow_stored_credentials_ = true;
62 } else {
63 options.exposeAllResponseHeaders = true;
64 // The author header set is empty, no preflight should go ahead.
65 options.preflightPolicy = WebURLLoaderOptions::PreventPreflight;
66 options.crossOriginRequestPolicy =
67 WebURLLoaderOptions::CrossOriginRequestPolicyUseAccessControl;
68 if (cors_mode_ == blink::WebMediaPlayer::CORSModeUseCredentials) {
69 options.allowCredentials = true;
70 allow_stored_credentials_ = true;
71 }
72 }
73 loader.reset(frame->createAssociatedURLLoader(options));
74 }
75
76 // Start the resource loading.
77 loader->loadAsynchronously(request, this);
78 active_loader_.reset(new ActiveLoader(loader.Pass()));
79 }
80
81 /////////////////////////////////////////////////////////////////////////////
82 // blink::WebURLLoaderClient implementation.
willSendRequest(WebURLLoader * loader,WebURLRequest & newRequest,const WebURLResponse & redirectResponse)83 void MediaInfoLoader::willSendRequest(
84 WebURLLoader* loader,
85 WebURLRequest& newRequest,
86 const WebURLResponse& redirectResponse) {
87 // The load may have been stopped and |ready_cb| is destroyed.
88 // In this case we shouldn't do anything.
89 if (ready_cb_.is_null()) {
90 // Set the url in the request to an invalid value (empty url).
91 newRequest.setURL(blink::WebURL());
92 return;
93 }
94
95 // Only allow |single_origin_| if we haven't seen a different origin yet.
96 if (single_origin_)
97 single_origin_ = url_.GetOrigin() == GURL(newRequest.url()).GetOrigin();
98
99 url_ = newRequest.url();
100 first_party_url_ = newRequest.firstPartyForCookies();
101 allow_stored_credentials_ = newRequest.allowStoredCredentials();
102 }
103
didSendData(WebURLLoader * loader,unsigned long long bytes_sent,unsigned long long total_bytes_to_be_sent)104 void MediaInfoLoader::didSendData(
105 WebURLLoader* loader,
106 unsigned long long bytes_sent,
107 unsigned long long total_bytes_to_be_sent) {
108 NOTIMPLEMENTED();
109 }
110
didReceiveResponse(WebURLLoader * loader,const WebURLResponse & response)111 void MediaInfoLoader::didReceiveResponse(
112 WebURLLoader* loader,
113 const WebURLResponse& response) {
114 DVLOG(1) << "didReceiveResponse: HTTP/"
115 << (response.httpVersion() == WebURLResponse::HTTP_0_9 ? "0.9" :
116 response.httpVersion() == WebURLResponse::HTTP_1_0 ? "1.0" :
117 response.httpVersion() == WebURLResponse::HTTP_1_1 ? "1.1" :
118 "Unknown")
119 << " " << response.httpStatusCode();
120 DCHECK(active_loader_.get());
121 if (!url_.SchemeIs("http") && !url_.SchemeIs("https")) {
122 DidBecomeReady(kOk);
123 return;
124 }
125 if (response.httpStatusCode() == kHttpOK) {
126 DidBecomeReady(kOk);
127 return;
128 }
129 loader_failed_ = true;
130 DidBecomeReady(kFailed);
131 }
132
didReceiveData(WebURLLoader * loader,const char * data,int data_length,int encoded_data_length)133 void MediaInfoLoader::didReceiveData(
134 WebURLLoader* loader,
135 const char* data,
136 int data_length,
137 int encoded_data_length) {
138 // Ignored.
139 }
140
didDownloadData(blink::WebURLLoader * loader,int dataLength,int encodedDataLength)141 void MediaInfoLoader::didDownloadData(
142 blink::WebURLLoader* loader,
143 int dataLength,
144 int encodedDataLength) {
145 NOTIMPLEMENTED();
146 }
147
didReceiveCachedMetadata(WebURLLoader * loader,const char * data,int data_length)148 void MediaInfoLoader::didReceiveCachedMetadata(
149 WebURLLoader* loader,
150 const char* data,
151 int data_length) {
152 NOTIMPLEMENTED();
153 }
154
didFinishLoading(WebURLLoader * loader,double finishTime,int64_t total_encoded_data_length)155 void MediaInfoLoader::didFinishLoading(
156 WebURLLoader* loader,
157 double finishTime,
158 int64_t total_encoded_data_length) {
159 DCHECK(active_loader_.get());
160 DidBecomeReady(kOk);
161 }
162
didFail(WebURLLoader * loader,const WebURLError & error)163 void MediaInfoLoader::didFail(
164 WebURLLoader* loader,
165 const WebURLError& error) {
166 DVLOG(1) << "didFail: reason=" << error.reason
167 << ", isCancellation=" << error.isCancellation
168 << ", domain=" << error.domain.utf8().data()
169 << ", localizedDescription="
170 << error.localizedDescription.utf8().data();
171 DCHECK(active_loader_.get());
172 loader_failed_ = true;
173 DidBecomeReady(kFailed);
174 }
175
HasSingleOrigin() const176 bool MediaInfoLoader::HasSingleOrigin() const {
177 DCHECK(ready_cb_.is_null())
178 << "Must become ready before calling HasSingleOrigin()";
179 return single_origin_;
180 }
181
DidPassCORSAccessCheck() const182 bool MediaInfoLoader::DidPassCORSAccessCheck() const {
183 DCHECK(ready_cb_.is_null())
184 << "Must become ready before calling DidPassCORSAccessCheck()";
185 return !loader_failed_ &&
186 cors_mode_ != blink::WebMediaPlayer::CORSModeUnspecified;
187 }
188
189 /////////////////////////////////////////////////////////////////////////////
190 // Helper methods.
191
DidBecomeReady(Status status)192 void MediaInfoLoader::DidBecomeReady(Status status) {
193 UMA_HISTOGRAM_TIMES("Media.InfoLoadDelay",
194 base::TimeTicks::Now() - start_time_);
195 active_loader_.reset();
196 if (!ready_cb_.is_null())
197 base::ResetAndReturn(&ready_cb_).Run(status, url_, first_party_url_,
198 allow_stored_credentials_);
199 }
200
201 } // namespace content
202