OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "chrome/browser/extensions/api/messaging/extension_message_port.h" | 5 #include "chrome/browser/extensions/api/messaging/extension_message_port.h" |
6 | 6 |
| 7 #include "base/scoped_observer.h" |
7 #include "chrome/browser/profiles/profile.h" | 8 #include "chrome/browser/profiles/profile.h" |
| 9 #include "content/public/browser/navigation_details.h" |
| 10 #include "content/public/browser/render_frame_host.h" |
8 #include "content/public/browser/render_process_host.h" | 11 #include "content/public/browser/render_process_host.h" |
| 12 #include "content/public/browser/web_contents.h" |
| 13 #include "content/public/browser/web_contents_observer.h" |
9 #include "extensions/browser/extension_host.h" | 14 #include "extensions/browser/extension_host.h" |
10 #include "extensions/browser/process_manager.h" | 15 #include "extensions/browser/process_manager.h" |
| 16 #include "extensions/browser/process_manager_observer.h" |
11 #include "extensions/common/extension_messages.h" | 17 #include "extensions/common/extension_messages.h" |
12 #include "extensions/common/manifest_handlers/background_info.h" | 18 #include "extensions/common/manifest_handlers/background_info.h" |
13 | 19 |
14 namespace extensions { | 20 namespace extensions { |
15 | 21 |
16 ExtensionMessagePort::ExtensionMessagePort(content::RenderProcessHost* process, | 22 const char kReceivingEndDoesntExistError[] = |
17 int routing_id, | 23 "Could not establish connection. Receiving end does not exist."; |
18 const std::string& extension_id) | 24 |
19 : process_(process), | 25 // Helper class to detect when frames are destroyed. |
20 routing_id_(routing_id), | 26 class ExtensionMessagePort::FrameTracker : public content::WebContentsObserver, |
21 extension_id_(extension_id), | 27 public ProcessManagerObserver { |
22 background_host_ptr_(NULL) { | 28 public: |
| 29 explicit FrameTracker(ExtensionMessagePort* port) |
| 30 : pm_observer_(this), port_(port) {} |
| 31 |
| 32 void TrackExtensionProcessFrames() { |
| 33 pm_observer_.Add(ProcessManager::Get(port_->browser_context_)); |
| 34 } |
| 35 |
| 36 void TrackTabFrames(content::WebContents* tab) { |
| 37 Observe(tab); |
| 38 } |
| 39 |
| 40 private: |
| 41 // content::WebContentsObserver overrides: |
| 42 void RenderFrameDeleted(content::RenderFrameHost* render_frame_host) |
| 43 override { |
| 44 port_->UnregisterFrame(render_frame_host); |
| 45 } |
| 46 |
| 47 void DidNavigateAnyFrame(content::RenderFrameHost* render_frame_host, |
| 48 const content::LoadCommittedDetails& details, |
| 49 const content::FrameNavigateParams&) override { |
| 50 if (!details.is_in_page) |
| 51 port_->UnregisterFrame(render_frame_host); |
| 52 } |
| 53 |
| 54 // extensions::ProcessManagerObserver overrides: |
| 55 void OnExtensionFrameUnregistered( |
| 56 const std::string& extension_id, |
| 57 content::RenderFrameHost* render_frame_host) override { |
| 58 if (extension_id == port_->extension_id_) |
| 59 port_->UnregisterFrame(render_frame_host); |
| 60 } |
| 61 |
| 62 ScopedObserver<ProcessManager, ProcessManagerObserver> pm_observer_; |
| 63 ExtensionMessagePort* port_; // Owns this FrameTracker. |
| 64 |
| 65 DISALLOW_COPY_AND_ASSIGN(FrameTracker); |
| 66 }; |
| 67 |
| 68 ExtensionMessagePort::ExtensionMessagePort( |
| 69 base::WeakPtr<MessageService> message_service, |
| 70 int port_id, |
| 71 const std::string& extension_id, |
| 72 content::RenderProcessHost* extension_process) |
| 73 : weak_message_service_(message_service), |
| 74 port_id_(port_id), |
| 75 extension_id_(extension_id), |
| 76 did_create_port_(false), |
| 77 browser_context_(extension_process->GetBrowserContext()), |
| 78 frames_(ProcessManager::Get(browser_context_)-> |
| 79 GetRenderFrameHostsForExtension(extension_id)), |
| 80 extension_process_(extension_process), |
| 81 background_host_ptr_(nullptr), |
| 82 frame_tracker_(new FrameTracker(this)) { |
| 83 frame_tracker_->TrackExtensionProcessFrames(); |
| 84 } |
| 85 |
| 86 ExtensionMessagePort::ExtensionMessagePort( |
| 87 base::WeakPtr<MessageService> message_service, |
| 88 int port_id, |
| 89 const std::string& extension_id, |
| 90 content::RenderFrameHost* rfh, |
| 91 bool include_child_frames) |
| 92 : weak_message_service_(message_service), |
| 93 port_id_(port_id), |
| 94 extension_id_(extension_id), |
| 95 did_create_port_(false), |
| 96 browser_context_(rfh->GetProcess()->GetBrowserContext()), |
| 97 extension_process_(nullptr), |
| 98 background_host_ptr_(nullptr), |
| 99 frame_tracker_(new FrameTracker(this)) { |
| 100 content::WebContents* tab = content::WebContents::FromRenderFrameHost(rfh); |
| 101 DCHECK(tab); |
| 102 frame_tracker_->TrackTabFrames(tab); |
| 103 if (include_child_frames) { |
| 104 tab->ForEachFrame(base::Bind(&ExtensionMessagePort::RegisterFrame, |
| 105 base::Unretained(this))); |
| 106 } else { |
| 107 RegisterFrame(rfh); |
| 108 } |
| 109 } |
| 110 |
| 111 ExtensionMessagePort::~ExtensionMessagePort() {} |
| 112 |
| 113 bool ExtensionMessagePort::IsValidPort() { |
| 114 return !frames_.empty(); |
23 } | 115 } |
24 | 116 |
25 void ExtensionMessagePort::DispatchOnConnect( | 117 void ExtensionMessagePort::DispatchOnConnect( |
26 int dest_port_id, | |
27 const std::string& channel_name, | 118 const std::string& channel_name, |
28 scoped_ptr<base::DictionaryValue> source_tab, | 119 scoped_ptr<base::DictionaryValue> source_tab, |
29 int source_frame_id, | 120 int source_frame_id, |
30 int target_tab_id, | |
31 int target_frame_id, | |
32 int guest_process_id, | 121 int guest_process_id, |
33 int guest_render_frame_routing_id, | 122 int guest_render_frame_routing_id, |
34 const std::string& source_extension_id, | 123 const std::string& source_extension_id, |
35 const std::string& target_extension_id, | 124 const std::string& target_extension_id, |
36 const GURL& source_url, | 125 const GURL& source_url, |
37 const std::string& tls_channel_id) { | 126 const std::string& tls_channel_id) { |
38 ExtensionMsg_TabConnectionInfo source; | 127 ExtensionMsg_TabConnectionInfo source; |
39 if (source_tab) | 128 if (source_tab) |
40 source.tab.Swap(source_tab.get()); | 129 source.tab.Swap(source_tab.get()); |
41 source.frame_id = source_frame_id; | 130 source.frame_id = source_frame_id; |
42 | 131 |
43 ExtensionMsg_ExternalConnectionInfo info; | 132 ExtensionMsg_ExternalConnectionInfo info; |
44 info.target_id = target_extension_id; | 133 info.target_id = target_extension_id; |
45 info.source_id = source_extension_id; | 134 info.source_id = source_extension_id; |
46 info.source_url = source_url; | 135 info.source_url = source_url; |
47 info.target_tab_id = target_tab_id; | |
48 info.target_frame_id = target_frame_id; | |
49 info.guest_process_id = guest_process_id; | 136 info.guest_process_id = guest_process_id; |
50 info.guest_render_frame_routing_id = guest_render_frame_routing_id; | 137 info.guest_render_frame_routing_id = guest_render_frame_routing_id; |
51 | 138 |
52 process_->Send(new ExtensionMsg_DispatchOnConnect( | 139 SendToPort(new ExtensionMsg_DispatchOnConnect( |
53 routing_id_, dest_port_id, channel_name, source, info, tls_channel_id)); | 140 MSG_ROUTING_NONE, port_id_, channel_name, source, info, tls_channel_id)); |
54 } | 141 } |
55 | 142 |
56 void ExtensionMessagePort::DispatchOnDisconnect( | 143 void ExtensionMessagePort::DispatchOnDisconnect( |
57 int source_port_id, | |
58 const std::string& error_message) { | 144 const std::string& error_message) { |
59 process_->Send(new ExtensionMsg_DispatchOnDisconnect( | 145 SendToPort(new ExtensionMsg_DispatchOnDisconnect( |
60 routing_id_, source_port_id, error_message)); | 146 MSG_ROUTING_NONE, port_id_, error_message)); |
61 } | 147 } |
62 | 148 |
63 void ExtensionMessagePort::DispatchOnMessage(const Message& message, | 149 void ExtensionMessagePort::DispatchOnMessage(const Message& message) { |
64 int target_port_id) { | 150 SendToPort(new ExtensionMsg_DeliverMessage( |
65 process_->Send(new ExtensionMsg_DeliverMessage( | 151 MSG_ROUTING_NONE, port_id_, message)); |
66 routing_id_, target_port_id, message)); | |
67 } | 152 } |
68 | 153 |
69 void ExtensionMessagePort::IncrementLazyKeepaliveCount() { | 154 void ExtensionMessagePort::IncrementLazyKeepaliveCount() { |
70 Profile* profile = | 155 ProcessManager* pm = ProcessManager::Get(browser_context_); |
71 Profile::FromBrowserContext(process_->GetBrowserContext()); | |
72 extensions::ProcessManager* pm = ProcessManager::Get(profile); | |
73 ExtensionHost* host = pm->GetBackgroundHostForExtension(extension_id_); | 156 ExtensionHost* host = pm->GetBackgroundHostForExtension(extension_id_); |
74 if (host && BackgroundInfo::HasLazyBackgroundPage(host->extension())) | 157 if (host && BackgroundInfo::HasLazyBackgroundPage(host->extension())) |
75 pm->IncrementLazyKeepaliveCount(host->extension()); | 158 pm->IncrementLazyKeepaliveCount(host->extension()); |
76 | 159 |
77 // Keep track of the background host, so when we decrement, we only do so if | 160 // Keep track of the background host, so when we decrement, we only do so if |
78 // the host hasn't reloaded. | 161 // the host hasn't reloaded. |
79 background_host_ptr_ = host; | 162 background_host_ptr_ = host; |
80 } | 163 } |
81 | 164 |
82 void ExtensionMessagePort::DecrementLazyKeepaliveCount() { | 165 void ExtensionMessagePort::DecrementLazyKeepaliveCount() { |
83 Profile* profile = | 166 ProcessManager* pm = ProcessManager::Get(browser_context_); |
84 Profile::FromBrowserContext(process_->GetBrowserContext()); | |
85 extensions::ProcessManager* pm = ProcessManager::Get(profile); | |
86 ExtensionHost* host = pm->GetBackgroundHostForExtension(extension_id_); | 167 ExtensionHost* host = pm->GetBackgroundHostForExtension(extension_id_); |
87 if (host && host == background_host_ptr_) | 168 if (host && host == background_host_ptr_) |
88 pm->DecrementLazyKeepaliveCount(host->extension()); | 169 pm->DecrementLazyKeepaliveCount(host->extension()); |
89 } | 170 } |
90 | 171 |
91 content::RenderProcessHost* ExtensionMessagePort::GetRenderProcessHost() { | 172 void ExtensionMessagePort::OpenPort(int process_id, int routing_id) { |
92 return process_; | 173 DCHECK(routing_id != MSG_ROUTING_NONE || extension_process_); |
| 174 |
| 175 // Mark port as active, so we can distinguish abnormal port closure from |
| 176 // explicit port closure via disconnect(). |
| 177 did_create_port_ = true; |
| 178 } |
| 179 |
| 180 void ExtensionMessagePort::ClosePort(int process_id, int routing_id) { |
| 181 if (routing_id == MSG_ROUTING_NONE) { |
| 182 // The only non-frame-specific message is the response to an unhandled |
| 183 // onConnect event in the extension process. |
| 184 DCHECK(extension_process_); |
| 185 frames_.clear(); |
| 186 CloseChannel(); |
| 187 return; |
| 188 } |
| 189 |
| 190 content::RenderFrameHost* rfh = |
| 191 content::RenderFrameHost::FromID(process_id, routing_id); |
| 192 if (rfh) |
| 193 UnregisterFrame(rfh); |
| 194 } |
| 195 |
| 196 void ExtensionMessagePort::CloseChannel() { |
| 197 std::string error_message = did_create_port_ ? std::string() : |
| 198 kReceivingEndDoesntExistError; |
| 199 if (weak_message_service_) |
| 200 weak_message_service_->CloseChannel(port_id_, error_message); |
| 201 } |
| 202 |
| 203 void ExtensionMessagePort::RegisterFrame(content::RenderFrameHost* rfh) { |
| 204 frames_.insert(rfh); |
| 205 } |
| 206 |
| 207 void ExtensionMessagePort::UnregisterFrame(content::RenderFrameHost* rfh) { |
| 208 if (frames_.erase(rfh) != 0 && frames_.empty()) |
| 209 CloseChannel(); |
| 210 } |
| 211 |
| 212 void ExtensionMessagePort::SendToPort(IPC::Message* msg) { |
| 213 DCHECK_GT(frames_.size(), 0UL); |
| 214 if (extension_process_) { |
| 215 // All extension frames reside in the same process, so we can just send a |
| 216 // single IPC message to the extension process as an optimization. |
| 217 // The frame tracking is then only used to make sure that the port gets |
| 218 // closed when all frames have closed / reloaded. |
| 219 msg->set_routing_id(MSG_ROUTING_CONTROL); |
| 220 extension_process_->Send(msg); |
| 221 return; |
| 222 } |
| 223 for (content::RenderFrameHost* rfh : frames_) { |
| 224 IPC::Message* msg_copy = new IPC::Message(*msg); |
| 225 msg_copy->set_routing_id(rfh->GetRoutingID()); |
| 226 rfh->Send(msg_copy); |
| 227 } |
| 228 delete msg; |
93 } | 229 } |
94 | 230 |
95 } // namespace extensions | 231 } // namespace extensions |
OLD | NEW |