16e8cce623b6e4fe0c9e4af605d675dd9d0338c38Torne (Richard Coles)// Copyright 2013 The Chromium Authors. All rights reserved. 26e8cce623b6e4fe0c9e4af605d675dd9d0338c38Torne (Richard Coles)// Use of this source code is governed by a BSD-style license that can be 36e8cce623b6e4fe0c9e4af605d675dd9d0338c38Torne (Richard Coles)// found in the LICENSE file. 46e8cce623b6e4fe0c9e4af605d675dd9d0338c38Torne (Richard Coles) 56e8cce623b6e4fe0c9e4af605d675dd9d0338c38Torne (Richard Coles)// TODO(vtl): I currently potentially overflow in doing index calculations. 66e8cce623b6e4fe0c9e4af605d675dd9d0338c38Torne (Richard Coles)// E.g., |start_index_| and |current_num_bytes_| fit into a |uint32_t|, but 71320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci// their sum may not. This is bad and poses a security risk. (We're currently 81320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci// saved by the limit on capacity -- the maximum size of the buffer, checked in 91320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci// |DataPipe::ValidateOptions()|, is currently sufficiently small.) 106e8cce623b6e4fe0c9e4af605d675dd9d0338c38Torne (Richard Coles) 116e8cce623b6e4fe0c9e4af605d675dd9d0338c38Torne (Richard Coles)#include "mojo/system/local_data_pipe.h" 126e8cce623b6e4fe0c9e4af605d675dd9d0338c38Torne (Richard Coles) 136e8cce623b6e4fe0c9e4af605d675dd9d0338c38Torne (Richard Coles)#include <string.h> 146e8cce623b6e4fe0c9e4af605d675dd9d0338c38Torne (Richard Coles) 156e8cce623b6e4fe0c9e4af605d675dd9d0338c38Torne (Richard Coles)#include <algorithm> 166e8cce623b6e4fe0c9e4af605d675dd9d0338c38Torne (Richard Coles) 171320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci#include "base/logging.h" 181320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci#include "mojo/system/constants.h" 191320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci 201320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tuccinamespace mojo { 211320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tuccinamespace system { 226e8cce623b6e4fe0c9e4af605d675dd9d0338c38Torne (Richard Coles) 236e8cce623b6e4fe0c9e4af605d675dd9d0338c38Torne (Richard Coles)LocalDataPipe::LocalDataPipe(const MojoCreateDataPipeOptions& options) 246e8cce623b6e4fe0c9e4af605d675dd9d0338c38Torne (Richard Coles) : DataPipe(true, true, options), start_index_(0), current_num_bytes_(0) { 251320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci // Note: |buffer_| is lazily allocated, since a common case will be that one 261320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci // of the handles is immediately passed off to another process. 271320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci} 281320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci 291320f92c476a1ad9d19dba2a48c72b75566198e9Primiano TucciLocalDataPipe::~LocalDataPipe() { 301320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci} 311320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci 321320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tuccivoid LocalDataPipe::ProducerCloseImplNoLock() { 336e8cce623b6e4fe0c9e4af605d675dd9d0338c38Torne (Richard Coles) // If the consumer is still open and we still have data, we have to keep the 346e8cce623b6e4fe0c9e4af605d675dd9d0338c38Torne (Richard Coles) // buffer around. Currently, we won't free it even if it empties later. (We 351320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci // could do this -- requiring a check on every read -- but that seems to be 361320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci // optimizing for the uncommon case.) 376e8cce623b6e4fe0c9e4af605d675dd9d0338c38Torne (Richard Coles) if (!consumer_open_no_lock() || !current_num_bytes_) { 386e8cce623b6e4fe0c9e4af605d675dd9d0338c38Torne (Richard Coles) // Note: There can only be a two-phase *read* (by the consumer) if we still 396e8cce623b6e4fe0c9e4af605d675dd9d0338c38Torne (Richard Coles) // have data. 406e8cce623b6e4fe0c9e4af605d675dd9d0338c38Torne (Richard Coles) DCHECK(!consumer_in_two_phase_read_no_lock()); 411320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci DestroyBufferNoLock(); 421320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci } 436e8cce623b6e4fe0c9e4af605d675dd9d0338c38Torne (Richard Coles)} 441320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci 451320f92c476a1ad9d19dba2a48c72b75566198e9Primiano TucciMojoResult LocalDataPipe::ProducerWriteDataImplNoLock( 461320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci UserPointer<const void> elements, 471320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci UserPointer<uint32_t> num_bytes, 481320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci uint32_t max_num_bytes_to_write, 491320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci uint32_t min_num_bytes_to_write) { 501320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci DCHECK_EQ(max_num_bytes_to_write % element_num_bytes(), 0u); 511320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci DCHECK_EQ(min_num_bytes_to_write % element_num_bytes(), 0u); 521320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci DCHECK_GT(max_num_bytes_to_write, 0u); 531320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci DCHECK(consumer_open_no_lock()); 541320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci 551320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci size_t num_bytes_to_write = 0; 561320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci if (may_discard()) { 571320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci if (min_num_bytes_to_write > capacity_num_bytes()) 581320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci return MOJO_RESULT_OUT_OF_RANGE; 591320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci 601320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci num_bytes_to_write = std::min(static_cast<size_t>(max_num_bytes_to_write), 611320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci capacity_num_bytes()); 621320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci if (num_bytes_to_write > capacity_num_bytes() - current_num_bytes_) { 631320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci // Discard as much as needed (discard oldest first). 641320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci MarkDataAsConsumedNoLock(num_bytes_to_write - 651320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci (capacity_num_bytes() - current_num_bytes_)); 661320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci // No need to wake up write waiters, since we're definitely going to leave 671320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci // the buffer full. 681320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci } 691320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci } else { 701320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci if (min_num_bytes_to_write > capacity_num_bytes() - current_num_bytes_) { 711320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci // Don't return "should wait" since you can't wait for a specified amount 721320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci // of data. 731320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci return MOJO_RESULT_OUT_OF_RANGE; 741320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci } 751320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci 761320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci num_bytes_to_write = std::min(static_cast<size_t>(max_num_bytes_to_write), 771320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci capacity_num_bytes() - current_num_bytes_); 781320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci } 791320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci if (num_bytes_to_write == 0) 801320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci return MOJO_RESULT_SHOULD_WAIT; 811320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci 821320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci // The amount we can write in our first |memcpy()|. 831320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci size_t num_bytes_to_write_first = 841320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci std::min(num_bytes_to_write, GetMaxNumBytesToWriteNoLock()); 851320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci // Do the first (and possibly only) |memcpy()|. 861320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci size_t first_write_index = 871320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci (start_index_ + current_num_bytes_) % capacity_num_bytes(); 881320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci EnsureBufferNoLock(); 891320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci elements.GetArray(buffer_.get() + first_write_index, 901320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci num_bytes_to_write_first); 911320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci 921320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci if (num_bytes_to_write_first < num_bytes_to_write) { 931320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci // The "second write index" is zero. 941320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci elements.At(num_bytes_to_write_first) 951320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci .GetArray(buffer_.get(), num_bytes_to_write - num_bytes_to_write_first); 961320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci } 971320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci 981320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci current_num_bytes_ += num_bytes_to_write; 991320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci DCHECK_LE(current_num_bytes_, capacity_num_bytes()); 1001320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci num_bytes.Put(static_cast<uint32_t>(num_bytes_to_write)); 1011320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci return MOJO_RESULT_OK; 1021320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci} 1031320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci 1041320f92c476a1ad9d19dba2a48c72b75566198e9Primiano TucciMojoResult LocalDataPipe::ProducerBeginWriteDataImplNoLock( 1051320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci UserPointer<void*> buffer, 1061320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci UserPointer<uint32_t> buffer_num_bytes, 1071320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci uint32_t min_num_bytes_to_write) { 1081320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci DCHECK(consumer_open_no_lock()); 1091320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci 1101320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci // The index we need to start writing at. 1111320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci size_t write_index = 1121320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci (start_index_ + current_num_bytes_) % capacity_num_bytes(); 1131320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci 1141320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci size_t max_num_bytes_to_write = GetMaxNumBytesToWriteNoLock(); 1151320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci if (min_num_bytes_to_write > max_num_bytes_to_write) { 1161320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci // In "may discard" mode, we can always write from the write index to the 1171320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci // end of the buffer. 1181320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci if (may_discard() && 1196e8cce623b6e4fe0c9e4af605d675dd9d0338c38Torne (Richard Coles) min_num_bytes_to_write <= capacity_num_bytes() - write_index) { 1206e8cce623b6e4fe0c9e4af605d675dd9d0338c38Torne (Richard Coles) // To do so, we need to discard an appropriate amount of data. 1216e8cce623b6e4fe0c9e4af605d675dd9d0338c38Torne (Richard Coles) // We should only reach here if the start index is after the write index! 122 DCHECK_GE(start_index_, write_index); 123 DCHECK_GT(min_num_bytes_to_write - max_num_bytes_to_write, 0u); 124 MarkDataAsConsumedNoLock(min_num_bytes_to_write - max_num_bytes_to_write); 125 max_num_bytes_to_write = min_num_bytes_to_write; 126 } else { 127 // Don't return "should wait" since you can't wait for a specified amount 128 // of data. 129 return MOJO_RESULT_OUT_OF_RANGE; 130 } 131 } 132 133 // Don't go into a two-phase write if there's no room. 134 if (max_num_bytes_to_write == 0) 135 return MOJO_RESULT_SHOULD_WAIT; 136 137 EnsureBufferNoLock(); 138 buffer.Put(buffer_.get() + write_index); 139 buffer_num_bytes.Put(static_cast<uint32_t>(max_num_bytes_to_write)); 140 set_producer_two_phase_max_num_bytes_written_no_lock( 141 static_cast<uint32_t>(max_num_bytes_to_write)); 142 return MOJO_RESULT_OK; 143} 144 145MojoResult LocalDataPipe::ProducerEndWriteDataImplNoLock( 146 uint32_t num_bytes_written) { 147 DCHECK_LE(num_bytes_written, 148 producer_two_phase_max_num_bytes_written_no_lock()); 149 current_num_bytes_ += num_bytes_written; 150 DCHECK_LE(current_num_bytes_, capacity_num_bytes()); 151 set_producer_two_phase_max_num_bytes_written_no_lock(0); 152 return MOJO_RESULT_OK; 153} 154 155HandleSignalsState LocalDataPipe::ProducerGetHandleSignalsStateImplNoLock() 156 const { 157 HandleSignalsState rv; 158 if (consumer_open_no_lock()) { 159 if ((may_discard() || current_num_bytes_ < capacity_num_bytes()) && 160 !producer_in_two_phase_write_no_lock()) 161 rv.satisfied_signals |= MOJO_HANDLE_SIGNAL_WRITABLE; 162 rv.satisfiable_signals |= MOJO_HANDLE_SIGNAL_WRITABLE; 163 } 164 return rv; 165} 166 167void LocalDataPipe::ConsumerCloseImplNoLock() { 168 // If the producer is around and in a two-phase write, we have to keep the 169 // buffer around. (We then don't free it until the producer is closed. This 170 // could be rectified, but again seems like optimizing for the uncommon case.) 171 if (!producer_open_no_lock() || !producer_in_two_phase_write_no_lock()) 172 DestroyBufferNoLock(); 173 current_num_bytes_ = 0; 174} 175 176MojoResult LocalDataPipe::ConsumerReadDataImplNoLock( 177 UserPointer<void> elements, 178 UserPointer<uint32_t> num_bytes, 179 uint32_t max_num_bytes_to_read, 180 uint32_t min_num_bytes_to_read) { 181 DCHECK_EQ(max_num_bytes_to_read % element_num_bytes(), 0u); 182 DCHECK_EQ(min_num_bytes_to_read % element_num_bytes(), 0u); 183 DCHECK_GT(max_num_bytes_to_read, 0u); 184 185 if (min_num_bytes_to_read > current_num_bytes_) { 186 // Don't return "should wait" since you can't wait for a specified amount of 187 // data. 188 return producer_open_no_lock() ? MOJO_RESULT_OUT_OF_RANGE 189 : MOJO_RESULT_FAILED_PRECONDITION; 190 } 191 192 size_t num_bytes_to_read = 193 std::min(static_cast<size_t>(max_num_bytes_to_read), current_num_bytes_); 194 if (num_bytes_to_read == 0) { 195 return producer_open_no_lock() ? MOJO_RESULT_SHOULD_WAIT 196 : MOJO_RESULT_FAILED_PRECONDITION; 197 } 198 199 // The amount we can read in our first |memcpy()|. 200 size_t num_bytes_to_read_first = 201 std::min(num_bytes_to_read, GetMaxNumBytesToReadNoLock()); 202 elements.PutArray(buffer_.get() + start_index_, num_bytes_to_read_first); 203 204 if (num_bytes_to_read_first < num_bytes_to_read) { 205 // The "second read index" is zero. 206 elements.At(num_bytes_to_read_first) 207 .PutArray(buffer_.get(), num_bytes_to_read - num_bytes_to_read_first); 208 } 209 210 MarkDataAsConsumedNoLock(num_bytes_to_read); 211 num_bytes.Put(static_cast<uint32_t>(num_bytes_to_read)); 212 return MOJO_RESULT_OK; 213} 214 215MojoResult LocalDataPipe::ConsumerDiscardDataImplNoLock( 216 UserPointer<uint32_t> num_bytes, 217 uint32_t max_num_bytes_to_discard, 218 uint32_t min_num_bytes_to_discard) { 219 DCHECK_EQ(max_num_bytes_to_discard % element_num_bytes(), 0u); 220 DCHECK_EQ(min_num_bytes_to_discard % element_num_bytes(), 0u); 221 DCHECK_GT(max_num_bytes_to_discard, 0u); 222 223 if (min_num_bytes_to_discard > current_num_bytes_) { 224 // Don't return "should wait" since you can't wait for a specified amount of 225 // data. 226 return producer_open_no_lock() ? MOJO_RESULT_OUT_OF_RANGE 227 : MOJO_RESULT_FAILED_PRECONDITION; 228 } 229 230 // Be consistent with other operations; error if no data available. 231 if (current_num_bytes_ == 0) { 232 return producer_open_no_lock() ? MOJO_RESULT_SHOULD_WAIT 233 : MOJO_RESULT_FAILED_PRECONDITION; 234 } 235 236 size_t num_bytes_to_discard = std::min( 237 static_cast<size_t>(max_num_bytes_to_discard), current_num_bytes_); 238 MarkDataAsConsumedNoLock(num_bytes_to_discard); 239 num_bytes.Put(static_cast<uint32_t>(num_bytes_to_discard)); 240 return MOJO_RESULT_OK; 241} 242 243MojoResult LocalDataPipe::ConsumerQueryDataImplNoLock( 244 UserPointer<uint32_t> num_bytes) { 245 // Note: This cast is safe, since the capacity fits into a |uint32_t|. 246 num_bytes.Put(static_cast<uint32_t>(current_num_bytes_)); 247 return MOJO_RESULT_OK; 248} 249 250MojoResult LocalDataPipe::ConsumerBeginReadDataImplNoLock( 251 UserPointer<const void*> buffer, 252 UserPointer<uint32_t> buffer_num_bytes, 253 uint32_t min_num_bytes_to_read) { 254 size_t max_num_bytes_to_read = GetMaxNumBytesToReadNoLock(); 255 if (min_num_bytes_to_read > max_num_bytes_to_read) { 256 // Don't return "should wait" since you can't wait for a specified amount of 257 // data. 258 return producer_open_no_lock() ? MOJO_RESULT_OUT_OF_RANGE 259 : MOJO_RESULT_FAILED_PRECONDITION; 260 } 261 262 // Don't go into a two-phase read if there's no data. 263 if (max_num_bytes_to_read == 0) { 264 return producer_open_no_lock() ? MOJO_RESULT_SHOULD_WAIT 265 : MOJO_RESULT_FAILED_PRECONDITION; 266 } 267 268 buffer.Put(buffer_.get() + start_index_); 269 buffer_num_bytes.Put(static_cast<uint32_t>(max_num_bytes_to_read)); 270 set_consumer_two_phase_max_num_bytes_read_no_lock( 271 static_cast<uint32_t>(max_num_bytes_to_read)); 272 return MOJO_RESULT_OK; 273} 274 275MojoResult LocalDataPipe::ConsumerEndReadDataImplNoLock( 276 uint32_t num_bytes_read) { 277 DCHECK_LE(num_bytes_read, consumer_two_phase_max_num_bytes_read_no_lock()); 278 DCHECK_LE(start_index_ + num_bytes_read, capacity_num_bytes()); 279 MarkDataAsConsumedNoLock(num_bytes_read); 280 set_consumer_two_phase_max_num_bytes_read_no_lock(0); 281 return MOJO_RESULT_OK; 282} 283 284HandleSignalsState LocalDataPipe::ConsumerGetHandleSignalsStateImplNoLock() 285 const { 286 HandleSignalsState rv; 287 if (current_num_bytes_ > 0) { 288 if (!consumer_in_two_phase_read_no_lock()) 289 rv.satisfied_signals |= MOJO_HANDLE_SIGNAL_READABLE; 290 rv.satisfiable_signals |= MOJO_HANDLE_SIGNAL_READABLE; 291 } else if (producer_open_no_lock()) { 292 rv.satisfiable_signals |= MOJO_HANDLE_SIGNAL_READABLE; 293 } 294 return rv; 295} 296 297void LocalDataPipe::EnsureBufferNoLock() { 298 DCHECK(producer_open_no_lock()); 299 if (buffer_) 300 return; 301 buffer_.reset(static_cast<char*>( 302 base::AlignedAlloc(capacity_num_bytes(), kDataPipeBufferAlignmentBytes))); 303} 304 305void LocalDataPipe::DestroyBufferNoLock() { 306#ifndef NDEBUG 307 // Scribble on the buffer to help detect use-after-frees. (This also helps the 308 // unit test detect certain bugs without needing ASAN or similar.) 309 if (buffer_) 310 memset(buffer_.get(), 0xcd, capacity_num_bytes()); 311#endif 312 buffer_.reset(); 313} 314 315size_t LocalDataPipe::GetMaxNumBytesToWriteNoLock() { 316 size_t next_index = start_index_ + current_num_bytes_; 317 if (next_index >= capacity_num_bytes()) { 318 next_index %= capacity_num_bytes(); 319 DCHECK_GE(start_index_, next_index); 320 DCHECK_EQ(start_index_ - next_index, 321 capacity_num_bytes() - current_num_bytes_); 322 return start_index_ - next_index; 323 } 324 return capacity_num_bytes() - next_index; 325} 326 327size_t LocalDataPipe::GetMaxNumBytesToReadNoLock() { 328 if (start_index_ + current_num_bytes_ > capacity_num_bytes()) 329 return capacity_num_bytes() - start_index_; 330 return current_num_bytes_; 331} 332 333void LocalDataPipe::MarkDataAsConsumedNoLock(size_t num_bytes) { 334 DCHECK_LE(num_bytes, current_num_bytes_); 335 start_index_ += num_bytes; 336 start_index_ %= capacity_num_bytes(); 337 current_num_bytes_ -= num_bytes; 338} 339 340} // namespace system 341} // namespace mojo 342