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 "remoting/host/desktop_session_agent.h" | 5 #include "remoting/host/desktop_session_agent.h" |
6 | 6 |
7 #include "base/logging.h" | 7 #include "base/logging.h" |
8 #include "ipc/ipc_channel_proxy.h" | 8 #include "ipc/ipc_channel_proxy.h" |
9 #include "ipc/ipc_message.h" | 9 #include "ipc/ipc_message.h" |
10 #include "ipc/ipc_message_macros.h" | 10 #include "ipc/ipc_message_macros.h" |
11 #include "remoting/base/auto_thread_task_runner.h" | 11 #include "remoting/base/auto_thread_task_runner.h" |
| 12 #include "remoting/base/capture_data.h" |
12 #include "remoting/host/chromoting_messages.h" | 13 #include "remoting/host/chromoting_messages.h" |
| 14 #include "remoting/proto/control.pb.h" |
| 15 #include "third_party/skia/include/core/SkRegion.h" |
13 | 16 |
14 namespace remoting { | 17 namespace remoting { |
15 | 18 |
16 DesktopSessionAgent::~DesktopSessionAgent() { | 19 DesktopSessionAgent::~DesktopSessionAgent() { |
17 DCHECK(caller_task_runner()->BelongsToCurrentThread()); | 20 DCHECK(!video_capturer_); |
18 } | 21 } |
19 | 22 |
20 bool DesktopSessionAgent::OnMessageReceived(const IPC::Message& message) { | 23 bool DesktopSessionAgent::OnMessageReceived(const IPC::Message& message) { |
21 DCHECK(caller_task_runner()->BelongsToCurrentThread()); | 24 DCHECK(caller_task_runner()->BelongsToCurrentThread()); |
22 | 25 |
23 NOTIMPLEMENTED(); | 26 bool handled = true; |
24 return false; | 27 IPC_BEGIN_MESSAGE_MAP(DesktopSessionAgent, message) |
| 28 IPC_MESSAGE_HANDLER(ChromotingNetworkDesktopMsg_CaptureFrame, |
| 29 OnCaptureFrame) |
| 30 IPC_MESSAGE_HANDLER(ChromotingNetworkDesktopMsg_InvalidateRegion, |
| 31 OnInvalidateRegion) |
| 32 IPC_MESSAGE_HANDLER(ChromotingNetworkDesktopMsg_SharedBufferCreated, |
| 33 OnSharedBufferCreated) |
| 34 IPC_END_MESSAGE_MAP() |
| 35 return handled; |
25 } | 36 } |
26 | 37 |
27 void DesktopSessionAgent::OnChannelConnected(int32 peer_pid) { | 38 void DesktopSessionAgent::OnChannelConnected(int32 peer_pid) { |
28 DCHECK(caller_task_runner()->BelongsToCurrentThread()); | 39 DCHECK(caller_task_runner()->BelongsToCurrentThread()); |
29 | 40 |
30 VLOG(1) << "IPC: desktop <- network (" << peer_pid << ")"; | 41 VLOG(1) << "IPC: desktop <- network (" << peer_pid << ")"; |
31 | |
32 NOTIMPLEMENTED(); | |
33 } | 42 } |
34 | 43 |
35 void DesktopSessionAgent::OnChannelError() { | 44 void DesktopSessionAgent::OnChannelError() { |
36 DCHECK(caller_task_runner()->BelongsToCurrentThread()); | 45 DCHECK(caller_task_runner()->BelongsToCurrentThread()); |
37 | 46 |
38 // Make sure the channel is closed. | 47 // Make sure the channel is closed. |
39 network_channel_.reset(); | 48 network_channel_.reset(); |
40 | 49 |
41 // Notify the caller that |this| can be destroyed now. | 50 // Notify the caller that the channel has been disconnected. |
42 done_task_.Run(); | 51 disconnected_task_.Run(); |
43 } | 52 } |
44 | 53 |
45 bool DesktopSessionAgent::Start(const base::Closure& done_task, | 54 scoped_refptr<SharedBuffer> DesktopSessionAgent::CreateSharedBuffer( |
| 55 uint32 size) { |
| 56 DCHECK(video_capture_task_runner()->BelongsToCurrentThread()); |
| 57 |
| 58 scoped_refptr<SharedBuffer> buffer = new SharedBuffer(size); |
| 59 if (buffer->ptr() != NULL) { |
| 60 buffer->set_id(next_shared_buffer_id_); |
| 61 shared_buffers_.push_back(buffer); |
| 62 |
| 63 // |next_shared_buffer_id_| starts from 1 and incrementing it by 2 makes |
| 64 // sure it is always odd and therefore zero is never used as a valid buffer |
| 65 // ID. |
| 66 // |
| 67 // It is very unlikely (though theoretically possible) to allocate the same |
| 68 // ID for two different buffers due to integer overflow. It should take |
| 69 // about a year of allocating 100 new buffers every second. Practically |
| 70 // speaking it never happens. |
| 71 next_shared_buffer_id_ += 2; |
| 72 |
| 73 SendToNetwork(new ChromotingDesktopNetworkMsg_CreateSharedBuffer( |
| 74 buffer->id(), buffer->handle(), buffer->size())); |
| 75 } |
| 76 |
| 77 return buffer; |
| 78 } |
| 79 |
| 80 void DesktopSessionAgent::ReleaseSharedBuffer( |
| 81 scoped_refptr<SharedBuffer> buffer) { |
| 82 DCHECK(video_capture_task_runner()->BelongsToCurrentThread()); |
| 83 DCHECK(buffer->id() != 0); |
| 84 |
| 85 SendToNetwork( |
| 86 new ChromotingDesktopNetworkMsg_ReleaseSharedBuffer(buffer->id())); |
| 87 } |
| 88 |
| 89 void DesktopSessionAgent::OnCaptureCompleted( |
| 90 scoped_refptr<CaptureData> capture_data) { |
| 91 DCHECK(video_capture_task_runner()->BelongsToCurrentThread()); |
| 92 |
| 93 // Serialize CaptureData |
| 94 SerializedCapturedData serialized_data; |
| 95 serialized_data.shared_buffer_id = capture_data->shared_buffer()->id(); |
| 96 serialized_data.dimensions = capture_data->size(); |
| 97 serialized_data.pixel_format = capture_data->pixel_format(); |
| 98 serialized_data.capture_time_ms = capture_data->capture_time_ms(); |
| 99 serialized_data.client_sequence_number = |
| 100 capture_data->client_sequence_number(); |
| 101 serialized_data.dpi = capture_data->dpi(); |
| 102 for (SkRegion::Iterator i(capture_data->dirty_region()); !i.done(); i.next()) |
| 103 serialized_data.dirty_region.push_back(i.rect()); |
| 104 |
| 105 SendToNetwork( |
| 106 new ChromotingDesktopNetworkMsg_CaptureCompleted(serialized_data)); |
| 107 } |
| 108 |
| 109 void DesktopSessionAgent::OnCursorShapeChanged( |
| 110 scoped_ptr<protocol::CursorShapeInfo> cursor_shape) { |
| 111 DCHECK(video_capture_task_runner()->BelongsToCurrentThread()); |
| 112 |
| 113 NOTIMPLEMENTED(); |
| 114 } |
| 115 |
| 116 bool DesktopSessionAgent::Start(const base::Closure& disconnected_task, |
46 IPC::PlatformFileForTransit* desktop_pipe_out) { | 117 IPC::PlatformFileForTransit* desktop_pipe_out) { |
47 DCHECK(caller_task_runner()->BelongsToCurrentThread()); | 118 DCHECK(caller_task_runner()->BelongsToCurrentThread()); |
48 | 119 |
49 done_task_ = done_task; | 120 disconnected_task_ = disconnected_task; |
50 return DoCreateNetworkChannel(desktop_pipe_out, &network_channel_); | 121 if (!CreateChannelForNetworkProcess(desktop_pipe_out, &network_channel_)) |
| 122 return false; |
| 123 |
| 124 // Start the video capturer. |
| 125 video_capture_task_runner()->PostTask( |
| 126 FROM_HERE, base::Bind(&DesktopSessionAgent::StartVideoCapturer, this)); |
| 127 return true; |
| 128 } |
| 129 |
| 130 void DesktopSessionAgent::Stop() { |
| 131 DCHECK(caller_task_runner()->BelongsToCurrentThread()); |
| 132 |
| 133 // Stop the video capturer. |
| 134 video_capture_task_runner()->PostTask( |
| 135 FROM_HERE, base::Bind(&DesktopSessionAgent::StopVideoCapturer, this)); |
| 136 } |
| 137 |
| 138 void DesktopSessionAgent::OnCaptureFrame() { |
| 139 if (!video_capture_task_runner()->BelongsToCurrentThread()) { |
| 140 video_capture_task_runner()->PostTask( |
| 141 FROM_HERE, |
| 142 base::Bind(&DesktopSessionAgent::OnCaptureFrame, this)); |
| 143 return; |
| 144 } |
| 145 |
| 146 // VideoFrameCapturer supports a very few (currently 2) outstanding capture |
| 147 // requests. The requests are serialized on |video_capture_task_runner()| task |
| 148 // runner. If the client issues more requests, pixel data in captured frames |
| 149 // will likely be corrupted but stability of VideoFrameCapturer will not be |
| 150 // affected. |
| 151 video_capturer_->CaptureInvalidRegion(); |
| 152 } |
| 153 |
| 154 void DesktopSessionAgent::OnInvalidateRegion( |
| 155 const std::vector<SkIRect>& invalid_rects) { |
| 156 if (!video_capture_task_runner()->BelongsToCurrentThread()) { |
| 157 video_capture_task_runner()->PostTask( |
| 158 FROM_HERE, |
| 159 base::Bind(&DesktopSessionAgent::OnInvalidateRegion, this, |
| 160 invalid_rects)); |
| 161 return; |
| 162 } |
| 163 |
| 164 SkIRect bounds = SkIRect::MakeSize(video_capturer_->size_most_recent()); |
| 165 |
| 166 // Convert |invalid_rects| into a region. |
| 167 SkRegion invalid_region; |
| 168 for (std::vector<SkIRect>::const_iterator i = invalid_rects.begin(); |
| 169 i != invalid_rects.end(); ++i) { |
| 170 // Validate each rectange and clip it to the frame bounds. If the rectangle |
| 171 // is not valid it is ignored. |
| 172 SkIRect rect; |
| 173 if (rect.intersect(*i, bounds)) { |
| 174 invalid_region.op(rect, SkRegion::kUnion_Op); |
| 175 } |
| 176 } |
| 177 |
| 178 video_capturer_->InvalidateRegion(invalid_region); |
| 179 } |
| 180 |
| 181 void DesktopSessionAgent::OnSharedBufferCreated(int id) { |
| 182 if (!video_capture_task_runner()->BelongsToCurrentThread()) { |
| 183 video_capture_task_runner()->PostTask( |
| 184 FROM_HERE, |
| 185 base::Bind(&DesktopSessionAgent::OnSharedBufferCreated, this, id)); |
| 186 return; |
| 187 } |
| 188 |
| 189 // Drop the cached reference to the buffer. |
| 190 SharedBuffers::iterator i = shared_buffers_.begin(); |
| 191 for (; i != shared_buffers_.end(); ++i) { |
| 192 if ((*i)->id() == id) { |
| 193 shared_buffers_.erase(i); |
| 194 break; |
| 195 } |
| 196 } |
| 197 } |
| 198 |
| 199 void DesktopSessionAgent::SendToNetwork(IPC::Message* message) { |
| 200 if (!caller_task_runner()->BelongsToCurrentThread()) { |
| 201 caller_task_runner()->PostTask( |
| 202 FROM_HERE, |
| 203 base::Bind(&DesktopSessionAgent::SendToNetwork, this, message)); |
| 204 return; |
| 205 } |
| 206 |
| 207 if (network_channel_) { |
| 208 network_channel_->Send(message); |
| 209 } else { |
| 210 delete message; |
| 211 } |
| 212 } |
| 213 |
| 214 void DesktopSessionAgent::StartVideoCapturer() { |
| 215 DCHECK(video_capture_task_runner()->BelongsToCurrentThread()); |
| 216 |
| 217 video_capturer_ = VideoFrameCapturer::CreateWithFactory(this); |
| 218 if (video_capturer_) |
| 219 video_capturer_->Start(this); |
| 220 } |
| 221 |
| 222 void DesktopSessionAgent::StopVideoCapturer() { |
| 223 DCHECK(video_capture_task_runner()->BelongsToCurrentThread()); |
| 224 |
| 225 if (video_capturer_) { |
| 226 video_capturer_->Stop(); |
| 227 video_capturer_.reset(); |
| 228 } |
| 229 |
| 230 // Free any shared buffers left. |
| 231 shared_buffers_.clear(); |
51 } | 232 } |
52 | 233 |
53 DesktopSessionAgent::DesktopSessionAgent( | 234 DesktopSessionAgent::DesktopSessionAgent( |
54 scoped_refptr<AutoThreadTaskRunner> caller_task_runner, | 235 scoped_refptr<AutoThreadTaskRunner> caller_task_runner, |
55 scoped_refptr<AutoThreadTaskRunner> io_task_runner) | 236 scoped_refptr<AutoThreadTaskRunner> io_task_runner, |
| 237 scoped_refptr<AutoThreadTaskRunner> video_capture_task_runner) |
56 : caller_task_runner_(caller_task_runner), | 238 : caller_task_runner_(caller_task_runner), |
57 io_task_runner_(io_task_runner) { | 239 io_task_runner_(io_task_runner), |
| 240 video_capture_task_runner_(video_capture_task_runner), |
| 241 next_shared_buffer_id_(1) { |
58 DCHECK(caller_task_runner_->BelongsToCurrentThread()); | 242 DCHECK(caller_task_runner_->BelongsToCurrentThread()); |
59 } | 243 } |
60 | 244 |
61 } // namespace remoting | 245 } // namespace remoting |
OLD | NEW |