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/tab_capture/tab_capture_registry.h" | 5 #include "chrome/browser/extensions/api/tab_capture/tab_capture_registry.h" |
6 | 6 |
7 #include "content/public/browser/browser_thread.h" | 7 #include "content/public/browser/browser_thread.h" |
8 #include "chrome/browser/extensions/event_names.h" | 8 #include "chrome/browser/extensions/event_names.h" |
9 #include "chrome/browser/extensions/event_router.h" | 9 #include "chrome/browser/extensions/event_router.h" |
10 #include "chrome/browser/extensions/extension_system.h" | 10 #include "chrome/browser/extensions/extension_system.h" |
(...skipping 15 matching lines...) Expand all Loading... | |
26 proxy_->Attach(this); | 26 proxy_->Attach(this); |
27 registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED, | 27 registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED, |
28 content::Source<Profile>(profile_)); | 28 content::Source<Profile>(profile_)); |
29 } | 29 } |
30 | 30 |
31 TabCaptureRegistry::~TabCaptureRegistry() { | 31 TabCaptureRegistry::~TabCaptureRegistry() { |
32 proxy_->Detach(); | 32 proxy_->Detach(); |
33 } | 33 } |
34 | 34 |
35 void TabCaptureRegistry::HandleRequestUpdateOnUIThread( | 35 void TabCaptureRegistry::HandleRequestUpdateOnUIThread( |
36 int render_process_id, | |
37 int render_view_id, | |
36 const content::MediaStreamDevice& device, | 38 const content::MediaStreamDevice& device, |
37 const content::MediaRequestState new_state) { | 39 const content::MediaRequestState new_state) { |
38 EventRouter* router = profile_ ? | 40 EventRouter* router = profile_ ? |
39 extensions::ExtensionSystem::Get(profile_)->event_router() : NULL; | 41 extensions::ExtensionSystem::Get(profile_)->event_router() : NULL; |
40 if (!router) | 42 if (!router) |
41 return; | 43 return; |
42 | 44 |
43 if (requests_.find(device.device_id) == requests_.end()) | 45 std::pair<int, int> id_pair = std::make_pair(render_process_id, |
no longer working on chromium
2012/12/07 14:13:10
nit, use key instead
justinlin
2012/12/07 15:50:09
Done.
| |
46 render_view_id); | |
47 | |
48 if (requests_.find(id_pair) == requests_.end()) { | |
49 LOG(ERROR) << "Receiving updates for invalid tab capture request."; | |
44 return; | 50 return; |
51 } | |
45 | 52 |
46 tab_capture::TabCaptureState state = | 53 tab_capture::TabCaptureState state = |
47 tab_capture::TAB_CAPTURE_TAB_CAPTURE_STATE_NONE; | 54 tab_capture::TAB_CAPTURE_TAB_CAPTURE_STATE_NONE; |
48 switch (new_state) { | 55 switch (new_state) { |
49 case content::MEDIA_REQUEST_STATE_REQUESTED: | 56 case content::MEDIA_REQUEST_STATE_REQUESTED: |
50 state = tab_capture::TAB_CAPTURE_TAB_CAPTURE_STATE_REQUESTED; | 57 state = tab_capture::TAB_CAPTURE_TAB_CAPTURE_STATE_REQUESTED; |
51 break; | 58 break; |
52 case content::MEDIA_REQUEST_STATE_PENDING_APPROVAL: | 59 case content::MEDIA_REQUEST_STATE_PENDING_APPROVAL: |
53 state = tab_capture::TAB_CAPTURE_TAB_CAPTURE_STATE_PENDING; | 60 state = tab_capture::TAB_CAPTURE_TAB_CAPTURE_STATE_PENDING; |
54 break; | 61 break; |
55 case content::MEDIA_REQUEST_STATE_DONE: | 62 case content::MEDIA_REQUEST_STATE_DONE: |
56 state = tab_capture::TAB_CAPTURE_TAB_CAPTURE_STATE_ACTIVE; | 63 state = tab_capture::TAB_CAPTURE_TAB_CAPTURE_STATE_ACTIVE; |
57 break; | 64 break; |
58 case content::MEDIA_REQUEST_STATE_CLOSING: | 65 case content::MEDIA_REQUEST_STATE_CLOSING: |
59 state = tab_capture::TAB_CAPTURE_TAB_CAPTURE_STATE_STOPPED; | 66 state = tab_capture::TAB_CAPTURE_TAB_CAPTURE_STATE_STOPPED; |
60 break; | 67 break; |
61 case content::MEDIA_REQUEST_STATE_ERROR: | 68 case content::MEDIA_REQUEST_STATE_ERROR: |
62 state = tab_capture::TAB_CAPTURE_TAB_CAPTURE_STATE_ERROR; | 69 state = tab_capture::TAB_CAPTURE_TAB_CAPTURE_STATE_ERROR; |
63 break; | 70 break; |
64 default: | 71 default: |
65 // TODO(justinlin): Implement muted state notification. | 72 // TODO(justinlin): Implement muted state notification. |
66 break; | 73 break; |
67 } | 74 } |
68 | 75 |
69 if (state == tab_capture::TAB_CAPTURE_TAB_CAPTURE_STATE_NONE) { | 76 if (state == tab_capture::TAB_CAPTURE_TAB_CAPTURE_STATE_NONE) { |
70 // This is a state we don't handle. | 77 // This is a state we don't handle. |
71 return; | 78 return; |
72 } | 79 } |
73 | 80 |
74 TabCaptureRegistry::TabCaptureRequest& request_info = | 81 TabCaptureRegistry::TabCaptureRequest& request_info = requests_[id_pair]; |
75 requests_[device.device_id]; | |
76 request_info.status = state; | 82 request_info.status = state; |
77 | 83 |
78 scoped_ptr<tab_capture::CaptureInfo> info(new tab_capture::CaptureInfo()); | 84 scoped_ptr<tab_capture::CaptureInfo> info(new tab_capture::CaptureInfo()); |
79 info->tab_id = request_info.tab_id; | 85 info->tab_id = request_info.tab_id; |
80 info->status = request_info.status; | 86 info->status = request_info.status; |
81 | 87 |
82 scoped_ptr<base::ListValue> args(new ListValue()); | 88 scoped_ptr<base::ListValue> args(new ListValue()); |
83 args->Append(info->ToValue().release()); | 89 args->Append(info->ToValue().release()); |
84 router->DispatchEventToExtension(request_info.extension_id, | 90 router->DispatchEventToExtension(request_info.extension_id, |
85 events::kOnTabCaptureStatusChanged, args.Pass(), profile_, GURL()); | 91 events::kOnTabCaptureStatusChanged, args.Pass(), profile_, GURL()); |
(...skipping 27 matching lines...) Expand all Loading... | |
113 requests_.erase(it++); | 119 requests_.erase(it++); |
114 } else { | 120 } else { |
115 ++it; | 121 ++it; |
116 } | 122 } |
117 } | 123 } |
118 break; | 124 break; |
119 } | 125 } |
120 } | 126 } |
121 } | 127 } |
122 | 128 |
123 bool TabCaptureRegistry::AddRequest( | 129 bool TabCaptureRegistry::AddRequest(const std::pair<int, int> key, |
124 const std::string& key, const TabCaptureRequest& request) { | 130 const TabCaptureRequest& request) { |
125 // Currently, we do not allow multiple active captures for same tab. | 131 // Currently, we do not allow multiple active captures for same tab. |
126 DCHECK(!key.empty()); | |
127 if (requests_.find(key) != requests_.end()) | 132 if (requests_.find(key) != requests_.end()) |
128 if (requests_[key].status != | 133 if (requests_[key].status != |
129 tab_capture::TAB_CAPTURE_TAB_CAPTURE_STATE_STOPPED && | 134 tab_capture::TAB_CAPTURE_TAB_CAPTURE_STATE_STOPPED && |
130 requests_[key].status != | 135 requests_[key].status != |
131 tab_capture::TAB_CAPTURE_TAB_CAPTURE_STATE_ERROR) | 136 tab_capture::TAB_CAPTURE_TAB_CAPTURE_STATE_ERROR) |
132 return false; | 137 return false; |
133 requests_[key] = request; | 138 requests_[key] = request; |
134 return true; | 139 return true; |
135 } | 140 } |
136 | 141 |
137 bool TabCaptureRegistry::VerifyRequest(const std::string& key) { | 142 bool TabCaptureRegistry::VerifyRequest(int render_process_id, |
138 return requests_.find(key) != requests_.end(); | 143 int render_view_id) { |
144 return requests_.find(std::make_pair( | |
145 render_process_id, render_view_id)) != requests_.end(); | |
139 } | 146 } |
140 | 147 |
141 void TabCaptureRegistry::MediaObserverProxy::Attach( | 148 void TabCaptureRegistry::MediaObserverProxy::Attach( |
142 TabCaptureRegistry* request_handler) { | 149 TabCaptureRegistry* request_handler) { |
143 handler_ = request_handler; | 150 handler_ = request_handler; |
144 BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, | 151 BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, |
145 base::Bind(&TabCaptureRegistry::MediaObserverProxy:: | 152 base::Bind(&TabCaptureRegistry::MediaObserverProxy:: |
146 RegisterAsMediaObserverOnIOThread, this, false)); | 153 RegisterAsMediaObserverOnIOThread, this, false)); |
147 } | 154 } |
148 | 155 |
149 void TabCaptureRegistry::MediaObserverProxy::Detach() { | 156 void TabCaptureRegistry::MediaObserverProxy::Detach() { |
150 handler_ = NULL; | 157 handler_ = NULL; |
151 BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, | 158 BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, |
152 base::Bind(&TabCaptureRegistry::MediaObserverProxy:: | 159 base::Bind(&TabCaptureRegistry::MediaObserverProxy:: |
153 RegisterAsMediaObserverOnIOThread, this, true)); | 160 RegisterAsMediaObserverOnIOThread, this, true)); |
154 } | 161 } |
155 | 162 |
156 void TabCaptureRegistry::MediaObserverProxy::RegisterAsMediaObserverOnIOThread( | 163 void TabCaptureRegistry::MediaObserverProxy::RegisterAsMediaObserverOnIOThread( |
157 bool unregister) { | 164 bool unregister) { |
158 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | 165 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
159 if (MediaInternals::GetInstance()) { | 166 if (MediaInternals::GetInstance()) { |
160 if (!unregister) | 167 if (!unregister) |
161 MediaInternals::GetInstance()->AddObserver(this); | 168 MediaInternals::GetInstance()->AddObserver(this); |
162 else | 169 else |
163 MediaInternals::GetInstance()->RemoveObserver(this); | 170 MediaInternals::GetInstance()->RemoveObserver(this); |
164 } | 171 } |
165 } | 172 } |
166 | 173 |
167 void TabCaptureRegistry::MediaObserverProxy::OnRequestUpdate( | 174 void TabCaptureRegistry::MediaObserverProxy::OnRequestUpdate( |
175 int render_process_id, | |
176 int render_view_id, | |
168 const content::MediaStreamDevice& device, | 177 const content::MediaStreamDevice& device, |
169 const content::MediaRequestState new_state) { | 178 const content::MediaRequestState new_state) { |
170 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | 179 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
171 | 180 |
172 // TODO(justinlin): We drop audio device events since they will occur in | 181 // TODO(justinlin): We drop audio device events since they will occur in |
173 // parallel with the video device events (we would get duplicate events). When | 182 // parallel with the video device events (we would get duplicate events). When |
174 // audio mirroring is implemented, we will want to grab those events when | 183 // audio mirroring is implemented, we will want to grab those events when |
175 // video is not requested. | 184 // video is not requested. |
176 if (device.type != content::MEDIA_TAB_VIDEO_CAPTURE) | 185 if (device.type != content::MEDIA_TAB_VIDEO_CAPTURE) |
177 return; | 186 return; |
178 | 187 |
179 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, | 188 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, |
180 base::Bind(&TabCaptureRegistry::MediaObserverProxy::UpdateOnUIThread, | 189 base::Bind(&TabCaptureRegistry::MediaObserverProxy::UpdateOnUIThread, |
181 this, device, new_state)); | 190 this, render_process_id, render_view_id, device, new_state)); |
182 } | 191 } |
183 | 192 |
184 void TabCaptureRegistry::MediaObserverProxy::UpdateOnUIThread( | 193 void TabCaptureRegistry::MediaObserverProxy::UpdateOnUIThread( |
194 int render_process_id, | |
195 int render_view_id, | |
185 const content::MediaStreamDevice& device, | 196 const content::MediaStreamDevice& device, |
186 const content::MediaRequestState new_state) { | 197 const content::MediaRequestState new_state) { |
187 if (handler_) | 198 if (handler_) |
188 handler_->HandleRequestUpdateOnUIThread(device, new_state); | 199 handler_->HandleRequestUpdateOnUIThread(render_process_id, |
200 render_view_id, | |
201 device, | |
202 new_state); | |
189 } | 203 } |
190 | 204 |
191 } // namespace extensions | 205 } // namespace extensions |
OLD | NEW |