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" |
13 | 15 |
14 namespace remoting { | 16 namespace remoting { |
15 | 17 |
16 DesktopSessionAgent::~DesktopSessionAgent() { | 18 DesktopSessionAgent::~DesktopSessionAgent() { |
17 DCHECK(caller_task_runner()->BelongsToCurrentThread()); | 19 DCHECK(!video_capturer_); |
18 } | 20 } |
19 | 21 |
20 bool DesktopSessionAgent::OnMessageReceived(const IPC::Message& message) { | 22 bool DesktopSessionAgent::OnMessageReceived(const IPC::Message& message) { |
21 DCHECK(caller_task_runner()->BelongsToCurrentThread()); | 23 DCHECK(caller_task_runner()->BelongsToCurrentThread()); |
22 | 24 |
23 NOTIMPLEMENTED(); | 25 bool handled = true; |
24 return false; | 26 IPC_BEGIN_MESSAGE_MAP(DesktopSessionAgent, message) |
| 27 IPC_MESSAGE_HANDLER(ChromotingNetworkDesktopMsg_CaptureFrame, |
| 28 OnCaptureFrame) |
| 29 IPC_MESSAGE_HANDLER(ChromotingNetworkDesktopMsg_InvalidateRegion, |
| 30 OnInvalidateRegion) |
| 31 IPC_MESSAGE_HANDLER(ChromotingNetworkDesktopMsg_SharedBufferCreated, |
| 32 OnSharedBufferCreated) |
| 33 IPC_END_MESSAGE_MAP() |
| 34 return handled; |
25 } | 35 } |
26 | 36 |
27 void DesktopSessionAgent::OnChannelConnected(int32 peer_pid) { | 37 void DesktopSessionAgent::OnChannelConnected(int32 peer_pid) { |
28 DCHECK(caller_task_runner()->BelongsToCurrentThread()); | 38 DCHECK(caller_task_runner()->BelongsToCurrentThread()); |
29 | 39 |
30 VLOG(1) << "IPC: desktop <- network (" << peer_pid << ")"; | 40 VLOG(1) << "IPC: desktop <- network (" << peer_pid << ")"; |
31 | |
32 NOTIMPLEMENTED(); | |
33 } | 41 } |
34 | 42 |
35 void DesktopSessionAgent::OnChannelError() { | 43 void DesktopSessionAgent::OnChannelError() { |
36 DCHECK(caller_task_runner()->BelongsToCurrentThread()); | 44 DCHECK(caller_task_runner()->BelongsToCurrentThread()); |
37 | 45 |
38 // Make sure the channel is closed. | 46 // Make sure the channel is closed. |
39 network_channel_.reset(); | 47 network_channel_.reset(); |
40 | 48 |
41 // Notify the caller that |this| can be destroyed now. | 49 // Notify the caller that the channel has been disconnected. |
42 done_task_.Run(); | 50 disconnected_task_.Run(); |
43 } | 51 } |
44 | 52 |
45 bool DesktopSessionAgent::Start(const base::Closure& done_task, | 53 scoped_refptr<SharedBuffer> DesktopSessionAgent::CreateSharedBuffer( |
| 54 uint32 size) { |
| 55 DCHECK(video_capture_task_runner()->BelongsToCurrentThread()); |
| 56 |
| 57 scoped_refptr<SharedBuffer> buffer = new SharedBuffer(size); |
| 58 if (buffer->ptr() != NULL) { |
| 59 // Use buffer's address as its ID. |
| 60 buffer->set_id(reinterpret_cast<intptr_t>(buffer.get())); |
| 61 shared_buffers_.push_back(buffer); |
| 62 |
| 63 SendToNetwork(new ChromotingDesktopNetworkMsg_CreateSharedBuffer( |
| 64 buffer->id(), buffer->handle(), buffer->size())); |
| 65 } |
| 66 |
| 67 return buffer; |
| 68 } |
| 69 |
| 70 void DesktopSessionAgent::ReleaseSharedBuffer( |
| 71 scoped_refptr<SharedBuffer> buffer) { |
| 72 DCHECK(video_capture_task_runner()->BelongsToCurrentThread()); |
| 73 DCHECK(buffer->id() != 0); |
| 74 |
| 75 SendToNetwork( |
| 76 new ChromotingDesktopNetworkMsg_ReleaseSharedBuffer(buffer->id())); |
| 77 } |
| 78 |
| 79 void DesktopSessionAgent::OnCaptureCompleted( |
| 80 scoped_refptr<CaptureData> capture_data) { |
| 81 DCHECK(video_capture_task_runner()->BelongsToCurrentThread()); |
| 82 |
| 83 // Serialize CaptureData |
| 84 SerializedCapturedData serialized_data; |
| 85 serialized_data.shared_buffer_id = capture_data->shared_buffer()->id(); |
| 86 serialized_data.dimensions = capture_data->size(); |
| 87 serialized_data.pixel_format = capture_data->pixel_format(); |
| 88 serialized_data.capture_time_ms = capture_data->capture_time_ms(); |
| 89 serialized_data.client_sequence_number = |
| 90 capture_data->client_sequence_number(); |
| 91 serialized_data.dpi = capture_data->dpi(); |
| 92 for (SkRegion::Iterator i(capture_data->dirty_region()); !i.done(); i.next()) |
| 93 serialized_data.dirty_region.push_back(i.rect()); |
| 94 |
| 95 SendToNetwork( |
| 96 new ChromotingDesktopNetworkMsg_CaptureCompleted(serialized_data)); |
| 97 } |
| 98 |
| 99 void DesktopSessionAgent::OnCursorShapeChanged( |
| 100 scoped_ptr<protocol::CursorShapeInfo> cursor_shape) { |
| 101 DCHECK(video_capture_task_runner()->BelongsToCurrentThread()); |
| 102 |
| 103 NOTIMPLEMENTED(); |
| 104 } |
| 105 |
| 106 bool DesktopSessionAgent::Start(const base::Closure& disconnected_task, |
46 IPC::PlatformFileForTransit* desktop_pipe_out) { | 107 IPC::PlatformFileForTransit* desktop_pipe_out) { |
47 DCHECK(caller_task_runner()->BelongsToCurrentThread()); | 108 DCHECK(caller_task_runner()->BelongsToCurrentThread()); |
48 | 109 |
49 done_task_ = done_task; | 110 disconnected_task_ = disconnected_task; |
50 return DoCreateNetworkChannel(desktop_pipe_out, &network_channel_); | 111 if (!CreateChannelForNetworkProcess(desktop_pipe_out, &network_channel_)) |
| 112 return false; |
| 113 |
| 114 // Start the video capturer. |
| 115 video_capture_task_runner()->PostTask( |
| 116 FROM_HERE, base::Bind(&DesktopSessionAgent::StartVideoCapturer, this)); |
| 117 return true; |
| 118 } |
| 119 |
| 120 void DesktopSessionAgent::Stop() { |
| 121 DCHECK(caller_task_runner()->BelongsToCurrentThread()); |
| 122 |
| 123 // Stop the video capturer. |
| 124 video_capture_task_runner()->PostTask( |
| 125 FROM_HERE, base::Bind(&DesktopSessionAgent::StopVideoCapturer, this)); |
| 126 } |
| 127 |
| 128 void DesktopSessionAgent::InvalidateRegion( |
| 129 scoped_ptr<SkRegion> invalid_region) { |
| 130 DCHECK(video_capture_task_runner()->BelongsToCurrentThread()); |
| 131 |
| 132 video_capturer_->InvalidateRegion(*invalid_region); |
| 133 } |
| 134 |
| 135 void DesktopSessionAgent::OnCaptureFrame() { |
| 136 if (!video_capture_task_runner()->BelongsToCurrentThread()) { |
| 137 video_capture_task_runner()->PostTask( |
| 138 FROM_HERE, |
| 139 base::Bind(&DesktopSessionAgent::OnCaptureFrame, this)); |
| 140 return; |
| 141 } |
| 142 |
| 143 video_capturer_->CaptureInvalidRegion(); |
| 144 } |
| 145 |
| 146 void DesktopSessionAgent::OnInvalidateRegion( |
| 147 const std::vector<SkIRect>& invalid_rects) { |
| 148 DCHECK(caller_task_runner()->BelongsToCurrentThread()); |
| 149 |
| 150 scoped_ptr<SkRegion> invalid_region(new SkRegion()); |
| 151 invalid_region->setRects(&invalid_rects[0], invalid_rects.size()); |
| 152 |
| 153 video_capture_task_runner()->PostTask( |
| 154 FROM_HERE, base::Bind(&DesktopSessionAgent::InvalidateRegion, this, |
| 155 base::Passed(&invalid_region))); |
| 156 } |
| 157 |
| 158 void DesktopSessionAgent::OnSharedBufferCreated(intptr_t id) { |
| 159 if (!video_capture_task_runner()->BelongsToCurrentThread()) { |
| 160 video_capture_task_runner()->PostTask( |
| 161 FROM_HERE, |
| 162 base::Bind(&DesktopSessionAgent::OnSharedBufferCreated, this, id)); |
| 163 return; |
| 164 } |
| 165 |
| 166 // Drop the cached reference to the buffer. |
| 167 SharedBuffers::iterator i = shared_buffers_.begin(); |
| 168 for (; i != shared_buffers_.end(); ++i) { |
| 169 if ((*i)->id() == id) { |
| 170 shared_buffers_.erase(i); |
| 171 break; |
| 172 } |
| 173 } |
| 174 } |
| 175 |
| 176 void DesktopSessionAgent::SendToNetwork(IPC::Message* message) { |
| 177 if (!caller_task_runner()->BelongsToCurrentThread()) { |
| 178 caller_task_runner()->PostTask( |
| 179 FROM_HERE, |
| 180 base::Bind(&DesktopSessionAgent::SendToNetwork, this, message)); |
| 181 return; |
| 182 } |
| 183 |
| 184 if (network_channel_) { |
| 185 network_channel_->Send(message); |
| 186 } else { |
| 187 delete message; |
| 188 } |
| 189 } |
| 190 |
| 191 void DesktopSessionAgent::StartVideoCapturer() { |
| 192 DCHECK(video_capture_task_runner()->BelongsToCurrentThread()); |
| 193 |
| 194 video_capturer_ = VideoFrameCapturer::CreateWithFactory(this); |
| 195 video_capturer_->Start(this); |
| 196 } |
| 197 |
| 198 void DesktopSessionAgent::StopVideoCapturer() { |
| 199 DCHECK(video_capture_task_runner()->BelongsToCurrentThread()); |
| 200 |
| 201 if (video_capturer_) { |
| 202 video_capturer_->Stop(); |
| 203 video_capturer_.reset(); |
| 204 } |
| 205 |
| 206 // Free any shared buffers left. |
| 207 shared_buffers_.clear(); |
51 } | 208 } |
52 | 209 |
53 DesktopSessionAgent::DesktopSessionAgent( | 210 DesktopSessionAgent::DesktopSessionAgent( |
54 scoped_refptr<AutoThreadTaskRunner> caller_task_runner, | 211 scoped_refptr<AutoThreadTaskRunner> caller_task_runner, |
55 scoped_refptr<AutoThreadTaskRunner> io_task_runner) | 212 scoped_refptr<AutoThreadTaskRunner> io_task_runner, |
| 213 scoped_refptr<AutoThreadTaskRunner> video_capture_task_runner) |
56 : caller_task_runner_(caller_task_runner), | 214 : caller_task_runner_(caller_task_runner), |
57 io_task_runner_(io_task_runner) { | 215 io_task_runner_(io_task_runner), |
| 216 video_capture_task_runner_(video_capture_task_runner) { |
58 DCHECK(caller_task_runner_->BelongsToCurrentThread()); | 217 DCHECK(caller_task_runner_->BelongsToCurrentThread()); |
59 } | 218 } |
60 | 219 |
61 } // namespace remoting | 220 } // namespace remoting |
OLD | NEW |