Update mojo sdk to rev afb4440fd5a10cba980878c326180b7ad7960480

mojo/edk/system/raw_channel.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "mojo/edk/system/raw_channel.h"
 
 #include <string.h>
 
 #include <algorithm>
 
@@ skipping 115 matching lines @@
         bytes_to_write};
     buffers->push_back(buffer);
     return;
   }
 
   // TODO(vtl): We could actually send out buffers from multiple messages, with
   // the "stopping" condition being reaching a message with platform handles
   // attached.
 
   // Write from both buffers.
-  DCHECK_EQ(
-      bytes_to_write,
-      message->main_buffer_size() - data_offset_ + transport_data_buffer_size);
+  DCHECK_EQ(bytes_to_write, message->main_buffer_size() - data_offset_ +
+                                transport_data_buffer_size);
   Buffer buffer1 = {
       static_cast<const char*>(message->main_buffer()) + data_offset_,
       message->main_buffer_size() - data_offset_};
   buffers->push_back(buffer1);
   Buffer buffer2 = {
       static_cast<const char*>(message->transport_data()->buffer()),
       transport_data_buffer_size};
   buffers->push_back(buffer2);
 }
 
@@ skipping 39 matching lines @@
     message_loop_for_io_ = nullptr;
     read_buffer_.reset();
     write_buffer_.reset();
     return false;
   }
 
   IOResult io_result = ScheduleRead();
   if (io_result != IO_PENDING) {
     // This will notify the delegate about the read failure. Although we're on
     // the I/O thread, don't call it in the nested context.
-    message_loop_for_io_->PostTask(FROM_HERE,
-                                   base::Bind(&RawChannel::OnReadCompleted,
-                                              weak_ptr_factory_.GetWeakPtr(),
-                                              io_result,
-                                              0));
+    message_loop_for_io_->PostTask(
+        FROM_HERE, base::Bind(&RawChannel::OnReadCompleted,
+                              weak_ptr_factory_.GetWeakPtr(), io_result, 0));
   }
 
   // ScheduleRead() failure is treated as a read failure (by notifying the
   // delegate), not as an init failure.
   return true;
 }
 
 void RawChannel::Shutdown() {
   DCHECK_EQ(base::MessageLoop::current(), message_loop_for_io_);
 
@@ skipping 26 matching lines @@
 
   EnqueueMessageNoLock(message.Pass());
   DCHECK_EQ(write_buffer_->data_offset_, 0u);
 
   size_t platform_handles_written = 0;
   size_t bytes_written = 0;
   IOResult io_result = WriteNoLock(&platform_handles_written, &bytes_written);
   if (io_result == IO_PENDING)
     return true;
 
-  bool result = OnWriteCompletedNoLock(
-      io_result, platform_handles_written, bytes_written);
+  bool result = OnWriteCompletedNoLock(io_result, platform_handles_written,
+                                       bytes_written);
   if (!result) {
     // Even if we're on the I/O thread, don't call |OnError()| in the nested
     // context.
-    message_loop_for_io_->PostTask(FROM_HERE,
-                                   base::Bind(&RawChannel::CallOnError,
-                                              weak_ptr_factory_.GetWeakPtr(),
-                                              Delegate::ERROR_WRITE));
+    message_loop_for_io_->PostTask(
+        FROM_HERE,
+        base::Bind(&RawChannel::CallOnError, weak_ptr_factory_.GetWeakPtr(),
+                   Delegate::ERROR_WRITE));
   }
 
   return result;
 }
 
 // Reminder: This must be thread-safe.
 bool RawChannel::IsWriteBufferEmpty() {
   base::AutoLock locker(write_lock_);
   return write_buffer_->message_queue_.empty();
 }
@@ skipping 37 matching lines @@
     size_t message_size;
     // Note that we rely on short-circuit evaluation here:
     //   - |read_buffer_start| may be an invalid index into
     //     |read_buffer_->buffer_| if |remaining_bytes| is zero.
     //   - |message_size| is only valid if |GetNextMessageSize()| returns true.
     // TODO(vtl): Use |message_size| more intelligently (e.g., to request the
     // next read).
     // TODO(vtl): Validate that |message_size| is sane.
     while (remaining_bytes > 0 && MessageInTransit::GetNextMessageSize(
                                       &read_buffer_->buffer_[read_buffer_start],
-                                      remaining_bytes,
-                                      &message_size) &&
+                                      remaining_bytes, &message_size) &&
            remaining_bytes >= message_size) {
       MessageInTransit::View message_view(
           message_size, &read_buffer_->buffer_[read_buffer_start]);
       DCHECK_EQ(message_view.total_size(), message_size);
 
       const char* error_message = nullptr;
       if (!message_view.IsValid(GetSerializedPlatformHandleSize(),
                                 &error_message)) {
         DCHECK(error_message);
         LOG(ERROR) << "Received invalid message: " << error_message;
         read_stopped_ = true;
         CallOnError(Delegate::ERROR_READ_BAD_MESSAGE);
         return;
       }
 
       if (message_view.type() == MessageInTransit::kTypeRawChannel) {
         if (!OnReadMessageForRawChannel(message_view)) {
           read_stopped_ = true;
           CallOnError(Delegate::ERROR_READ_BAD_MESSAGE);
           return;
         }
       } else {
         embedder::ScopedPlatformHandleVectorPtr platform_handles;
         if (message_view.transport_data_buffer()) {
           size_t num_platform_handles;
           const void* platform_handle_table;
           TransportData::GetPlatformHandleTable(
-              message_view.transport_data_buffer(),
-              &num_platform_handles,
+              message_view.transport_data_buffer(), &num_platform_handles,
               &platform_handle_table);
 
           if (num_platform_handles > 0) {
             platform_handles =
                 GetReadPlatformHandles(num_platform_handles,
                                        platform_handle_table).Pass();
             if (!platform_handles) {
               LOG(ERROR) << "Invalid number of platform handles received";
               read_stopped_ = true;
               CallOnError(Delegate::ERROR_READ_BAD_MESSAGE);
@@ skipping 20 matching lines @@
       // Update our state.
       read_buffer_start += message_size;
       remaining_bytes -= message_size;
     }
 
     if (read_buffer_start > 0) {
       // Move data back to start.
       read_buffer_->num_valid_bytes_ = remaining_bytes;
       if (read_buffer_->num_valid_bytes_ > 0) {
         memmove(&read_buffer_->buffer_[0],
-                &read_buffer_->buffer_[read_buffer_start],
-                remaining_bytes);
+                &read_buffer_->buffer_[read_buffer_start], remaining_bytes);
       }
       read_buffer_start = 0;
     }
 
     if (read_buffer_->buffer_.size() - read_buffer_->num_valid_bytes_ <
         kReadSize) {
       // Use power-of-2 buffer sizes.
       // TODO(vtl): Make sure the buffer doesn't get too large (and enforce the
       // maximum message size to whatever extent necessary).
       // TODO(vtl): We may often be able to peek at the header and get the real
@@ skipping 28 matching lines @@
   bool did_fail = false;
   {
     base::AutoLock locker(write_lock_);
     DCHECK_EQ(write_stopped_, write_buffer_->message_queue_.empty());
 
     if (write_stopped_) {
       NOTREACHED();
       return;
     }
 
-    did_fail = !OnWriteCompletedNoLock(
-                   io_result, platform_handles_written, bytes_written);
+    did_fail = !OnWriteCompletedNoLock(io_result, platform_handles_written,
+                                       bytes_written);
   }
 
   if (did_fail)
     CallOnError(Delegate::ERROR_WRITE);
 }
 
 void RawChannel::EnqueueMessageNoLock(scoped_ptr<MessageInTransit> message) {
   write_lock_.AssertAcquired();
   write_buffer_->message_queue_.push_back(message.release());
 }
@@ skipping 65 matching lines @@
 
   write_stopped_ = true;
   STLDeleteElements(&write_buffer_->message_queue_);
   write_buffer_->platform_handles_offset_ = 0;
   write_buffer_->data_offset_ = 0;
   return false;
 }
 
 }  // namespace system
 }  // namespace mojo