OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 1 // Copyright 2013 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 "mojo/edk/system/data_pipe_consumer_dispatcher.h" | 5 #include "mojo/edk/system/data_pipe_consumer_dispatcher.h" |
6 | 6 |
7 #include <algorithm> | 7 #include <algorithm> |
| 8 #include <utility> |
8 | 9 |
9 #include "base/bind.h" | 10 #include "base/bind.h" |
10 #include "base/logging.h" | 11 #include "base/logging.h" |
11 #include "base/message_loop/message_loop.h" | 12 #include "base/message_loop/message_loop.h" |
12 #include "mojo/edk/embedder/embedder_internal.h" | 13 #include "mojo/edk/embedder/embedder_internal.h" |
13 #include "mojo/edk/embedder/platform_shared_buffer.h" | 14 #include "mojo/edk/embedder/platform_shared_buffer.h" |
14 #include "mojo/edk/embedder/platform_support.h" | 15 #include "mojo/edk/embedder/platform_support.h" |
15 #include "mojo/edk/system/data_pipe.h" | 16 #include "mojo/edk/system/data_pipe.h" |
16 | 17 |
17 namespace mojo { | 18 namespace mojo { |
18 namespace edk { | 19 namespace edk { |
19 | 20 |
20 struct SharedMemoryHeader { | 21 struct SharedMemoryHeader { |
21 uint32_t data_size; | 22 uint32_t data_size; |
22 uint32_t read_buffer_size; | 23 uint32_t read_buffer_size; |
23 }; | 24 }; |
24 | 25 |
25 void DataPipeConsumerDispatcher::Init( | 26 void DataPipeConsumerDispatcher::Init( |
26 ScopedPlatformHandle message_pipe, | 27 ScopedPlatformHandle message_pipe, |
27 char* serialized_read_buffer, size_t serialized_read_buffer_size) { | 28 char* serialized_read_buffer, size_t serialized_read_buffer_size) { |
28 if (message_pipe.is_valid()) { | 29 if (message_pipe.is_valid()) { |
29 channel_ = RawChannel::Create(message_pipe.Pass()); | 30 channel_ = RawChannel::Create(std::move(message_pipe)); |
30 channel_->SetSerializedData( | 31 channel_->SetSerializedData( |
31 serialized_read_buffer, serialized_read_buffer_size, nullptr, 0u, | 32 serialized_read_buffer, serialized_read_buffer_size, nullptr, 0u, |
32 nullptr, nullptr); | 33 nullptr, nullptr); |
33 internal::g_io_thread_task_runner->PostTask( | 34 internal::g_io_thread_task_runner->PostTask( |
34 FROM_HERE, base::Bind(&DataPipeConsumerDispatcher::InitOnIO, this)); | 35 FROM_HERE, base::Bind(&DataPipeConsumerDispatcher::InitOnIO, this)); |
35 } else { | 36 } else { |
36 // The data pipe consumer could have read all the data and the producer | 37 // The data pipe consumer could have read all the data and the producer |
37 // closed its end subsequently (before the consumer was sent). In that case | 38 // closed its end subsequently (before the consumer was sent). In that case |
38 // when we deserialize the consumer we must make sure to set error_ or | 39 // when we deserialize the consumer we must make sure to set error_ or |
39 // otherwise the peer-closed signal will never be satisfied. | 40 // otherwise the peer-closed signal will never be satisfied. |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
75 &shared_memory_handle, &shared_memory_size); | 76 &shared_memory_handle, &shared_memory_size); |
76 | 77 |
77 scoped_refptr<DataPipeConsumerDispatcher> rv(Create(options)); | 78 scoped_refptr<DataPipeConsumerDispatcher> rv(Create(options)); |
78 | 79 |
79 char* serialized_read_buffer = nullptr; | 80 char* serialized_read_buffer = nullptr; |
80 size_t serialized_read_buffer_size = 0; | 81 size_t serialized_read_buffer_size = 0; |
81 scoped_refptr<PlatformSharedBuffer> shared_buffer; | 82 scoped_refptr<PlatformSharedBuffer> shared_buffer; |
82 scoped_ptr<PlatformSharedBufferMapping> mapping; | 83 scoped_ptr<PlatformSharedBufferMapping> mapping; |
83 if (shared_memory_size) { | 84 if (shared_memory_size) { |
84 shared_buffer = internal::g_platform_support->CreateSharedBufferFromHandle( | 85 shared_buffer = internal::g_platform_support->CreateSharedBufferFromHandle( |
85 shared_memory_size, shared_memory_handle.Pass()); | 86 shared_memory_size, std::move(shared_memory_handle)); |
86 mapping = shared_buffer->Map(0, shared_memory_size); | 87 mapping = shared_buffer->Map(0, shared_memory_size); |
87 char* buffer = static_cast<char*>(mapping->GetBase()); | 88 char* buffer = static_cast<char*>(mapping->GetBase()); |
88 SharedMemoryHeader* header = reinterpret_cast<SharedMemoryHeader*>(buffer); | 89 SharedMemoryHeader* header = reinterpret_cast<SharedMemoryHeader*>(buffer); |
89 buffer += sizeof(SharedMemoryHeader); | 90 buffer += sizeof(SharedMemoryHeader); |
90 if (header->data_size) { | 91 if (header->data_size) { |
91 rv->data_.assign(buffer, buffer + header->data_size); | 92 rv->data_.assign(buffer, buffer + header->data_size); |
92 buffer += header->data_size; | 93 buffer += header->data_size; |
93 } | 94 } |
94 | 95 |
95 if (header->read_buffer_size) { | 96 if (header->read_buffer_size) { |
96 serialized_read_buffer = buffer; | 97 serialized_read_buffer = buffer; |
97 serialized_read_buffer_size = header->read_buffer_size; | 98 serialized_read_buffer_size = header->read_buffer_size; |
98 buffer += header->read_buffer_size; | 99 buffer += header->read_buffer_size; |
99 } | 100 } |
100 } | 101 } |
101 | 102 |
102 rv->Init(platform_handle.Pass(), serialized_read_buffer, | 103 rv->Init(std::move(platform_handle), serialized_read_buffer, |
103 serialized_read_buffer_size); | 104 serialized_read_buffer_size); |
104 return rv; | 105 return rv; |
105 } | 106 } |
106 | 107 |
107 DataPipeConsumerDispatcher::DataPipeConsumerDispatcher( | 108 DataPipeConsumerDispatcher::DataPipeConsumerDispatcher( |
108 const MojoCreateDataPipeOptions& options) | 109 const MojoCreateDataPipeOptions& options) |
109 : options_(options), | 110 : options_(options), |
110 channel_(nullptr), | 111 channel_(nullptr), |
111 calling_init_(false), | 112 calling_init_(false), |
112 in_two_phase_read_(false), | 113 in_two_phase_read_(false), |
(...skipping 23 matching lines...) Expand all Loading... |
136 | 137 |
137 scoped_refptr<Dispatcher> | 138 scoped_refptr<Dispatcher> |
138 DataPipeConsumerDispatcher::CreateEquivalentDispatcherAndCloseImplNoLock() { | 139 DataPipeConsumerDispatcher::CreateEquivalentDispatcherAndCloseImplNoLock() { |
139 lock().AssertAcquired(); | 140 lock().AssertAcquired(); |
140 | 141 |
141 SerializeInternal(); | 142 SerializeInternal(); |
142 | 143 |
143 scoped_refptr<DataPipeConsumerDispatcher> rv = Create(options_); | 144 scoped_refptr<DataPipeConsumerDispatcher> rv = Create(options_); |
144 data_.swap(rv->data_); | 145 data_.swap(rv->data_); |
145 serialized_read_buffer_.swap(rv->serialized_read_buffer_); | 146 serialized_read_buffer_.swap(rv->serialized_read_buffer_); |
146 rv->serialized_platform_handle_ = serialized_platform_handle_.Pass(); | 147 rv->serialized_platform_handle_ = std::move(serialized_platform_handle_); |
147 rv->serialized_ = true; | 148 rv->serialized_ = true; |
148 | 149 |
149 return scoped_refptr<Dispatcher>(rv.get()); | 150 return scoped_refptr<Dispatcher>(rv.get()); |
150 } | 151 } |
151 | 152 |
152 MojoResult DataPipeConsumerDispatcher::ReadDataImplNoLock( | 153 MojoResult DataPipeConsumerDispatcher::ReadDataImplNoLock( |
153 void* elements, | 154 void* elements, |
154 uint32_t* num_bytes, | 155 uint32_t* num_bytes, |
155 MojoReadDataFlags flags) { | 156 MojoReadDataFlags flags) { |
156 lock().AssertAcquired(); | 157 lock().AssertAcquired(); |
(...skipping 209 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
366 | 367 |
367 if (!serialized_read_buffer_.empty()) { | 368 if (!serialized_read_buffer_.empty()) { |
368 memcpy(start, &serialized_read_buffer_[0], | 369 memcpy(start, &serialized_read_buffer_[0], |
369 serialized_read_buffer_.size()); | 370 serialized_read_buffer_.size()); |
370 start += serialized_read_buffer_.size(); | 371 start += serialized_read_buffer_.size(); |
371 } | 372 } |
372 | 373 |
373 shared_memory_handle.reset(shared_buffer->PassPlatformHandle().release()); | 374 shared_memory_handle.reset(shared_buffer->PassPlatformHandle().release()); |
374 } | 375 } |
375 | 376 |
376 DataPipe::EndSerialize( | 377 DataPipe::EndSerialize(options_, std::move(serialized_platform_handle_), |
377 options_, | 378 std::move(shared_memory_handle), shared_memory_size, |
378 serialized_platform_handle_.Pass(), | 379 destination, actual_size, platform_handles); |
379 shared_memory_handle.Pass(), shared_memory_size, | |
380 destination, actual_size, platform_handles); | |
381 CloseImplNoLock(); | 380 CloseImplNoLock(); |
382 return true; | 381 return true; |
383 } | 382 } |
384 | 383 |
385 void DataPipeConsumerDispatcher::TransportStarted() { | 384 void DataPipeConsumerDispatcher::TransportStarted() { |
386 started_transport_.Acquire(); | 385 started_transport_.Acquire(); |
387 } | 386 } |
388 | 387 |
389 void DataPipeConsumerDispatcher::TransportEnded() { | 388 void DataPipeConsumerDispatcher::TransportEnded() { |
390 started_transport_.Release(); | 389 started_transport_.Release(); |
(...skipping 101 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
492 CHECK(!write_error) << "DataPipeConsumerDispatcher doesn't write."; | 491 CHECK(!write_error) << "DataPipeConsumerDispatcher doesn't write."; |
493 | 492 |
494 channel_ = nullptr; | 493 channel_ = nullptr; |
495 } | 494 } |
496 | 495 |
497 serialized_ = true; | 496 serialized_ = true; |
498 } | 497 } |
499 | 498 |
500 } // namespace edk | 499 } // namespace edk |
501 } // namespace mojo | 500 } // namespace mojo |
OLD | NEW |