OLD | NEW |
---|---|
(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 "extensions/browser/web_ui_user_script_loader.h" | |
6 | |
7 #include "base/bind.h" | |
8 #include "base/pickle.h" | |
9 #include "base/strings/string_util.h" | |
10 #include "content/public/browser/browser_context.h" | |
11 #include "content/public/browser/browser_thread.h" | |
12 #include "extensions/browser/content_verifier.h" | |
13 | |
14 namespace { | |
15 using LoadScriptsCallback = | |
16 base::Callback<void(scoped_ptr<extensions::UserScriptList>, | |
17 scoped_ptr<base::SharedMemory>)>; | |
18 | |
19 void SerializeOnFileThread(scoped_ptr<extensions::UserScriptList> user_scripts, | |
20 LoadScriptsCallback callback) { | |
21 scoped_ptr<base::SharedMemory> memory = | |
22 extensions::UserScriptLoader::Serialize(*user_scripts); | |
23 content::BrowserThread::PostTask( | |
24 content::BrowserThread::UI, FROM_HERE, | |
25 base::Bind(callback, base::Passed(&user_scripts), base::Passed(&memory))); | |
26 } | |
27 | |
28 } // namespace | |
29 | |
30 struct WebUIUserScriptLoader::UserScriptRenderInfo { | |
31 int render_process_id; | |
32 int render_view_id; | |
33 | |
34 UserScriptRenderInfo() : render_process_id(-1), render_view_id(-1) {} | |
35 | |
36 UserScriptRenderInfo(int render_process_id, int render_view_id) | |
37 : render_process_id(render_process_id), render_view_id(render_view_id) {} | |
38 | |
39 bool operator<(const UserScriptRenderInfo& other) { | |
40 if (render_process_id != other.render_process_id) | |
41 return render_process_id < other.render_process_id; | |
42 | |
43 if (render_view_id != other.render_view_id) | |
44 return render_view_id < other.render_view_id; | |
45 | |
46 return false; | |
47 } | |
48 }; | |
49 | |
50 WebUIUserScriptLoader::WebUIUserScriptLoader( | |
51 content::BrowserContext* browser_context, | |
52 const HostID& host_id) | |
53 : UserScriptLoader(browser_context, host_id), | |
Devlin
2015/04/21 22:32:20
you're missing an initialization here
Xi Han
2015/04/22 15:32:11
Got it:)
| |
54 user_scripts_cache_(nullptr), | |
55 weak_factory_(this) { | |
56 SetReady(true); | |
57 } | |
58 | |
59 WebUIUserScriptLoader::~WebUIUserScriptLoader() { | |
60 } | |
61 | |
62 void WebUIUserScriptLoader::AddScripts( | |
63 const std::set<extensions::UserScript>& scripts, | |
64 int render_process_id, | |
65 int render_view_id) { | |
66 UserScriptRenderInfo info(render_process_id, render_view_id); | |
67 for (const extensions::UserScript& script : scripts) { | |
68 script_render_info_map_.insert( | |
69 std::pair<int, UserScriptRenderInfo>(script.id(), info)); | |
70 } | |
71 | |
72 extensions::UserScriptLoader::AddScripts(scripts); | |
73 } | |
74 | |
75 void WebUIUserScriptLoader::LoadScripts( | |
76 scoped_ptr<extensions::UserScriptList> user_scripts, | |
77 const std::set<HostID>& changed_hosts, | |
78 const std::set<int>& added_script_ids) { | |
79 user_scripts_cache_.swap(user_scripts); | |
80 ClearScripts(false); | |
81 | |
82 // The total number of the tasks is used to trace whether all the fetches | |
83 // are complete. Therefore, we store all the fetcher pointers in |fetchers_| | |
84 // before we get theis number. Once we get the total number, start each | |
85 // fetch tasks. | |
86 complete_fetchers_ = 0; | |
87 | |
88 for (extensions::UserScript& script : *user_scripts_cache_) { | |
89 if (added_script_ids.count(script.id()) == 0) | |
90 continue; | |
91 | |
92 int render_process_id = -1; | |
93 int render_view_id = -1; | |
94 auto iter = script_render_info_map_.find(script.id()); | |
95 DCHECK(iter != script_render_info_map_.end()); | |
96 render_process_id = iter->second.render_process_id; | |
97 render_view_id = iter->second.render_view_id; | |
98 | |
99 for (size_t k = 0; k < script.js_scripts().size(); ++k) { | |
100 extensions::UserScript::File& file = script.js_scripts()[k]; | |
Devlin
2015/04/21 22:32:20
The fact that you make this temporary implies the
Xi Han
2015/04/22 15:32:11
Copy and paste from old code, updated:)
| |
101 if (file.GetContent().empty()) { | |
Devlin
2015/04/21 22:32:20
Let's extract these lines into a lambda, since the
Xi Han
2015/04/22 15:32:11
The whole loops are identical (only the difference
| |
102 scoped_ptr<WebUIURLFetcher> fetcher(new WebUIURLFetcher( | |
103 browser_context(), render_process_id, render_view_id, file.url(), | |
104 base::Bind(&WebUIUserScriptLoader::OnSingleWebUIURLFetchComplete, | |
105 base::Unretained(this), &file))); | |
Devlin
2015/04/21 22:32:20
You should comment on why the Unretained is safe.
Xi Han
2015/04/22 15:32:11
Done.
| |
106 fetchers_.push_back(fetcher.release()); | |
107 } | |
108 } | |
109 for (size_t k = 0; k < script.css_scripts().size(); ++k) { | |
110 extensions::UserScript::File& file = script.css_scripts()[k]; | |
111 if (file.GetContent().empty()) { | |
112 scoped_ptr<WebUIURLFetcher> fetcher(new WebUIURLFetcher( | |
113 browser_context(), render_process_id, render_view_id, file.url(), | |
114 base::Bind(&WebUIUserScriptLoader::OnSingleWebUIURLFetchComplete, | |
115 base::Unretained(this), &file))); | |
116 fetchers_.push_back(fetcher.release()); | |
117 } | |
118 } | |
119 script_render_info_map_.erase(script.id()); | |
120 } | |
121 | |
122 // If no fetch is needed, call OnWebUIURLFetchComplete directly. | |
123 if (fetchers_.empty()) { | |
124 OnWebUIURLFetchComplete(); | |
125 return; | |
126 } | |
127 for (auto fetcher : fetchers_) | |
128 fetcher->Start(); | |
129 } | |
130 | |
131 void WebUIUserScriptLoader::OnSingleWebUIURLFetchComplete( | |
132 extensions::UserScript::File* script_file, | |
133 bool success, | |
134 const std::string& data) { | |
135 if (success) { | |
136 // Remove BOM from the content. | |
137 std::string::size_type index = data.find(base::kUtf8ByteOrderMark); | |
138 if (index == 0) | |
139 script_file->set_content(data.substr(strlen(base::kUtf8ByteOrderMark))); | |
140 else | |
141 script_file->set_content(data); | |
142 } | |
143 | |
144 ++complete_fetchers_; | |
145 if (complete_fetchers_ == fetchers_.size()) { | |
146 complete_fetchers_ = 0; | |
147 OnWebUIURLFetchComplete(); | |
148 fetchers_.clear(); | |
149 } | |
150 } | |
151 | |
152 void WebUIUserScriptLoader::OnWebUIURLFetchComplete() { | |
153 content::BrowserThread::PostTask( | |
154 content::BrowserThread::FILE, FROM_HERE, | |
155 base::Bind(&SerializeOnFileThread, base::Passed(&user_scripts_cache_), | |
156 base::Bind(&WebUIUserScriptLoader::OnScriptsLoaded, | |
157 weak_factory_.GetWeakPtr()))); | |
158 user_scripts_cache_.reset(nullptr); | |
Devlin
2015/04/21 22:32:20
base::Passed should reset the pointer already.
Al
Xi Han
2015/04/22 15:32:11
I see, I will update the place wheRE calling user_
| |
159 } | |
OLD | NEW |