Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(127)

Side by Side Diff: mojo/shell/network_fetcher.cc

Issue 1342503003: Move fetching logic out of ApplicationManager, eliminate url mappings. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: . Created 5 years, 3 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « mojo/shell/network_fetcher.h ('k') | mojo/shell/update_fetcher.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
1 // Copyright 2015 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 "mojo/shell/network_fetcher.h"
6
7 #include "base/bind.h"
8 #include "base/command_line.h"
9 #include "base/files/file.h"
10 #include "base/files/file_path.h"
11 #include "base/files/file_util.h"
12 #include "base/message_loop/message_loop.h"
13 #include "base/process/process.h"
14 #include "base/stl_util.h"
15 #include "base/strings/string_number_conversions.h"
16 #include "base/strings/string_util.h"
17 #include "base/strings/stringprintf.h"
18 #include "base/strings/utf_string_conversions.h"
19 #include "base/trace_event/trace_event.h"
20 #include "crypto/secure_hash.h"
21 #include "crypto/sha2.h"
22 #include "mojo/common/common_type_converters.h"
23 #include "mojo/common/data_pipe_utils.h"
24 #include "mojo/common/url_type_converters.h"
25 #include "mojo/services/network/public/interfaces/url_loader_factory.mojom.h"
26 #include "mojo/shell/data_pipe_peek.h"
27 #include "mojo/shell/switches.h"
28
29 namespace mojo {
30 namespace shell {
31
32 NetworkFetcher::NetworkFetcher(bool disable_cache,
33 mojo::URLRequestPtr request,
34 URLLoaderFactory* url_loader_factory,
35 const FetchCallback& loader_callback)
36 : Fetcher(loader_callback),
37 disable_cache_(false),
38 url_(request->url.To<GURL>()),
39 weak_ptr_factory_(this) {
40 StartNetworkRequest(request.Pass(), url_loader_factory);
41 }
42
43 NetworkFetcher::~NetworkFetcher() {
44 }
45
46 const GURL& NetworkFetcher::GetURL() const {
47 return url_;
48 }
49
50 GURL NetworkFetcher::GetRedirectURL() const {
51 if (!response_)
52 return GURL::EmptyGURL();
53
54 if (response_->redirect_url.is_null())
55 return GURL::EmptyGURL();
56
57 return GURL(response_->redirect_url);
58 }
59
60 GURL NetworkFetcher::GetRedirectReferer() const {
61 if (!response_)
62 return GURL::EmptyGURL();
63
64 if (response_->redirect_referrer.is_null())
65 return GURL::EmptyGURL();
66
67 return GURL(response_->redirect_referrer);
68 }
69 URLResponsePtr NetworkFetcher::AsURLResponse(base::TaskRunner* task_runner,
70 uint32_t skip) {
71 if (skip != 0) {
72 MojoResult result = ReadDataRaw(
73 response_->body.get(), nullptr, &skip,
74 MOJO_READ_DATA_FLAG_ALL_OR_NONE | MOJO_READ_DATA_FLAG_DISCARD);
75 DCHECK_EQ(result, MOJO_RESULT_OK);
76 }
77 return response_.Pass();
78 }
79
80 void NetworkFetcher::RecordCacheToURLMapping(const base::FilePath& path,
81 const GURL& url) {
82 // This is used to extract symbols on android.
83 // TODO(eseidel): All users of this log should move to using the map file.
84 VLOG(1) << "Caching mojo app " << url << " at " << path.value();
85
86 base::FilePath temp_dir;
87 base::GetTempDir(&temp_dir);
88 base::ProcessId pid = base::Process::Current().Pid();
89 std::string map_name = base::StringPrintf("mojo_shell.%d.maps", pid);
90 base::FilePath map_path = temp_dir.AppendASCII(map_name);
91
92 // TODO(eseidel): Paths or URLs with spaces will need quoting.
93 std::string map_entry =
94 base::StringPrintf("%s %s\n", path.value().c_str(), url.spec().c_str());
95 // TODO(eseidel): AppendToFile is missing O_CREAT, crbug.com/450696
96 if (!PathExists(map_path)) {
97 base::WriteFile(map_path, map_entry.data(),
98 static_cast<int>(map_entry.length()));
99 } else {
100 base::AppendToFile(map_path, map_entry.data(),
101 static_cast<int>(map_entry.length()));
102 }
103 }
104
105 // For remote debugging, GDB needs to be, a apriori, aware of the filename a
106 // library will be loaded from. AppIds should be be both predictable and unique,
107 // but any hash would work. Currently we use sha256 from crypto/secure_hash.h
108 bool NetworkFetcher::ComputeAppId(const base::FilePath& path,
109 std::string* digest_string) {
110 scoped_ptr<crypto::SecureHash> ctx(
111 crypto::SecureHash::Create(crypto::SecureHash::SHA256));
112 base::File file(path, base::File::FLAG_OPEN | base::File::FLAG_READ);
113 if (!file.IsValid()) {
114 LOG(ERROR) << "Failed to open " << path.value() << " for computing AppId";
115 return false;
116 }
117 char buf[1024];
118 while (file.IsValid()) {
119 int bytes_read = file.ReadAtCurrentPos(buf, sizeof(buf));
120 if (bytes_read == 0)
121 break;
122 ctx->Update(buf, bytes_read);
123 }
124 if (!file.IsValid()) {
125 LOG(ERROR) << "Error reading " << path.value();
126 return false;
127 }
128 // The output is really a vector of unit8, we're cheating by using a string.
129 std::string output(crypto::kSHA256Length, 0);
130 ctx->Finish(string_as_array(&output), output.size());
131 output = base::HexEncode(output.c_str(), output.size());
132 // Using lowercase for compatiblity with sha256sum output.
133 *digest_string = base::ToLowerASCII(output);
134 return true;
135 }
136
137 bool NetworkFetcher::RenameToAppId(const GURL& url,
138 const base::FilePath& old_path,
139 base::FilePath* new_path) {
140 std::string app_id;
141 if (!ComputeAppId(old_path, &app_id))
142 return false;
143
144 // Using a hash of the url as a directory to prevent a race when the same
145 // bytes are downloaded from 2 different urls. In particular, if the same
146 // application is connected to twice concurrently with different query
147 // parameters, the directory will be different, which will prevent the
148 // collision.
149 std::string dirname = base::HexEncode(
150 crypto::SHA256HashString(url.spec()).data(), crypto::kSHA256Length);
151
152 base::FilePath temp_dir;
153 base::GetTempDir(&temp_dir);
154 base::FilePath app_dir = temp_dir.AppendASCII(dirname);
155 // The directory is leaked, because it can be reused at any time if the same
156 // application is downloaded. Deleting it would be racy. This is only
157 // happening when --predictable-app-filenames is used.
158 bool result = base::CreateDirectoryAndGetError(app_dir, nullptr);
159 DCHECK(result);
160 std::string unique_name = base::StringPrintf("%s.mojo", app_id.c_str());
161 *new_path = app_dir.AppendASCII(unique_name);
162 return base::Move(old_path, *new_path);
163 }
164
165 void NetworkFetcher::CopyCompleted(
166 base::Callback<void(const base::FilePath&, bool)> callback,
167 bool success) {
168 if (success) {
169 if (base::CommandLine::ForCurrentProcess()->HasSwitch(
170 switches::kPredictableAppFilenames)) {
171 // The copy completed, now move to $TMP/$APP_ID.mojo before the dlopen.
172 success = false;
173 base::FilePath new_path;
174 if (RenameToAppId(url_, path_, &new_path)) {
175 if (base::PathExists(new_path)) {
176 path_ = new_path;
177 success = true;
178 }
179 }
180 }
181 }
182
183 if (success)
184 RecordCacheToURLMapping(path_, url_);
185
186 base::MessageLoop::current()->PostTask(FROM_HERE,
187 base::Bind(callback, path_, success));
188 }
189
190 void NetworkFetcher::AsPath(
191 base::TaskRunner* task_runner,
192 base::Callback<void(const base::FilePath&, bool)> callback) {
193 if (!path_.empty() || !response_) {
194 base::MessageLoop::current()->PostTask(
195 FROM_HERE, base::Bind(callback, path_, base::PathExists(path_)));
196 return;
197 }
198
199 base::CreateTemporaryFile(&path_);
200 common::CopyToFile(response_->body.Pass(), path_, task_runner,
201 base::Bind(&NetworkFetcher::CopyCompleted,
202 weak_ptr_factory_.GetWeakPtr(), callback));
203 }
204
205 std::string NetworkFetcher::MimeType() {
206 return response_->mime_type;
207 }
208
209 bool NetworkFetcher::HasMojoMagic() {
210 std::string magic;
211 return BlockingPeekNBytes(response_->body.get(), &magic, strlen(kMojoMagic),
212 kPeekTimeout) &&
213 magic == kMojoMagic;
214 }
215
216 bool NetworkFetcher::PeekFirstLine(std::string* line) {
217 return BlockingPeekLine(response_->body.get(), line, kMaxShebangLength,
218 kPeekTimeout);
219 }
220
221 void NetworkFetcher::StartNetworkRequest(mojo::URLRequestPtr request,
222 URLLoaderFactory* url_loader_factory) {
223 TRACE_EVENT_ASYNC_BEGIN1("mojo_shell", "NetworkFetcher::NetworkRequest", this,
224 "url", request->url.To<std::string>());
225 request->auto_follow_redirects = false;
226 request->bypass_cache = disable_cache_;
227
228 url_loader_factory->CreateURLLoader(GetProxy(&url_loader_));
229 url_loader_->Start(request.Pass(),
230 base::Bind(&NetworkFetcher::OnLoadComplete,
231 weak_ptr_factory_.GetWeakPtr()));
232 }
233
234 void NetworkFetcher::OnLoadComplete(URLResponsePtr response) {
235 TRACE_EVENT_ASYNC_END0("mojo_shell", "NetworkFetcher::NetworkRequest", this);
236 scoped_ptr<Fetcher> owner(this);
237 if (response->error) {
238 LOG(ERROR) << "Error (" << response->error->code << ": "
239 << response->error->description << ") while fetching "
240 << response->url;
241 loader_callback_.Run(nullptr);
242 return;
243 }
244
245 if (response->status_code >= 400 && response->status_code < 600) {
246 LOG(ERROR) << "Error (" << response->status_code << ": "
247 << response->status_line << "): "
248 << "while fetching " << response->url;
249 loader_callback_.Run(nullptr);
250 return;
251 }
252
253 response_ = response.Pass();
254 loader_callback_.Run(owner.Pass());
255 }
256
257 } // namespace shell
258 } // namespace mojo
OLDNEW
« no previous file with comments | « mojo/shell/network_fetcher.h ('k') | mojo/shell/update_fetcher.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698