Update mojo sdk to rev e01f9a49449381a5eb430c1fd88bf2cae73ec35a

mojo/edk/system/raw_channel_posix.cc

 // Copyright 2013 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 <errno.h>
 #include <sys/uio.h>
 #include <unistd.h>
 
@@ skipping 117 matching lines @@
         platform_handles->size() > embedder::kPlatformChannelMaxNumHandles) {
       // We can't attach all the FDs to a single message, so we have to "split"
       // the message. Send as many control messages as needed first with FDs
       // attached (and no data).
       size_t i = 0;
       for (; platform_handles->size() - i >
                  embedder::kPlatformChannelMaxNumHandles;
            i += embedder::kPlatformChannelMaxNumHandles) {
         scoped_ptr<MessageInTransit> fd_message(new MessageInTransit(
             MessageInTransit::kTypeRawChannel,
-            MessageInTransit::kSubtypeRawChannelPosixExtraPlatformHandles,
-            0,
+            MessageInTransit::kSubtypeRawChannelPosixExtraPlatformHandles, 0,
             nullptr));
         embedder::ScopedPlatformHandleVectorPtr fds(
             new embedder::PlatformHandleVector(
                 platform_handles->begin() + i,
                 platform_handles->begin() + i +
                     embedder::kPlatformChannelMaxNumHandles));
         fd_message->SetTransportData(
             make_scoped_ptr(new TransportData(fds.Pass())));
         RawChannel::EnqueueMessageNoLock(fd_message.Pass());
       }
@@ skipping 96 matching lines @@
     write_result = embedder::PlatformChannelSendmsgWithHandles(
         fd_.get(), iov, buffer_count, platform_handles, num_platform_handles);
     for (size_t i = 0; i < num_platform_handles; i++)
       platform_handles[i].CloseIfNecessary();
   } else {
     std::vector<WriteBuffer::Buffer> buffers;
     write_buffer_no_lock()->GetBuffers(&buffers);
     DCHECK(!buffers.empty());
 
     if (buffers.size() == 1) {
-      write_result = embedder::PlatformChannelWrite(
-          fd_.get(), buffers[0].addr, buffers[0].size);
+      write_result = embedder::PlatformChannelWrite(fd_.get(), buffers[0].addr,
+                                                    buffers[0].size);
     } else {
       const size_t kMaxBufferCount = 10;
       iovec iov[kMaxBufferCount];
       size_t buffer_count = std::min(buffers.size(), kMaxBufferCount);
       for (size_t i = 0; i < buffer_count; ++i) {
         iov[i].iov_base = const_cast<char*>(buffers[i].addr);
         iov[i].iov_len = buffers[i].size;
       }
 
       write_result =
@@ skipping 27 matching lines @@
   // If we're not on the I/O thread, we have to post a task to do this.
   if (base::MessageLoop::current() != message_loop_for_io()) {
     message_loop_for_io()->PostTask(FROM_HERE,
                                     base::Bind(&RawChannelPosix::WaitToWrite,
                                                weak_ptr_factory_.GetWeakPtr()));
     pending_write_ = true;
     return IO_PENDING;
   }
 
   if (message_loop_for_io()->WatchFileDescriptor(
-          fd_.get().fd,
-          false,
-          base::MessageLoopForIO::WATCH_WRITE,
-          write_watcher_.get(),
-          this)) {
+          fd_.get().fd, false, base::MessageLoopForIO::WATCH_WRITE,
+          write_watcher_.get(), this)) {
     pending_write_ = true;
     return IO_PENDING;
   }
 
   return IO_FAILED_UNKNOWN;
 }
 
 bool RawChannelPosix::OnInit() {
   DCHECK_EQ(base::MessageLoop::current(), message_loop_for_io());
 
   DCHECK(!read_watcher_);
   read_watcher_.reset(new base::MessageLoopForIO::FileDescriptorWatcher());
   DCHECK(!write_watcher_);
   write_watcher_.reset(new base::MessageLoopForIO::FileDescriptorWatcher());
 
   if (!message_loop_for_io()->WatchFileDescriptor(
-          fd_.get().fd,
-          true,
-          base::MessageLoopForIO::WATCH_READ,
-          read_watcher_.get(),
-          this)) {
+          fd_.get().fd, true, base::MessageLoopForIO::WATCH_READ,
+          read_watcher_.get(), this)) {
     // TODO(vtl): I'm not sure |WatchFileDescriptor()| actually fails cleanly
     // (in the sense of returning the message loop's state to what it was before
     // it was called).
     read_watcher_.reset();
     write_watcher_.reset();
     return false;
   }
 
   return true;
 }
@@ skipping 73 matching lines @@
   if (read_platform_handles_.size() > old_num_platform_handles) {
     DCHECK_LE(read_platform_handles_.size() - old_num_platform_handles,
               embedder::kPlatformChannelMaxNumHandles);
 
     // We should never accumulate more than |TransportData::kMaxPlatformHandles
     // + embedder::kPlatformChannelMaxNumHandles| handles. (The latter part is
     // possible because we could have accumulated all the handles for a message,
     // then received the message data plus the first set of handles for the next
     // message in the subsequent |recvmsg()|.)
     if (read_platform_handles_.size() >
-        (TransportData::kMaxPlatformHandles +
+        (TransportData::GetMaxPlatformHandles() +
          embedder::kPlatformChannelMaxNumHandles)) {
       LOG(ERROR) << "Received too many platform handles";
       embedder::CloseAllPlatformHandles(&read_platform_handles_);
       read_platform_handles_.clear();
       return IO_FAILED_UNKNOWN;
     }
   }
 
   if (read_result > 0) {
     *bytes_read = static_cast<size_t>(read_result);
@@ skipping 13 matching lines @@
   PLOG(WARNING) << "recvmsg";
   return IO_FAILED_UNKNOWN;
 }
 
 void RawChannelPosix::WaitToWrite() {
   DCHECK_EQ(base::MessageLoop::current(), message_loop_for_io());
 
   DCHECK(write_watcher_);
 
   if (!message_loop_for_io()->WatchFileDescriptor(
-          fd_.get().fd,
-          false,
-          base::MessageLoopForIO::WATCH_WRITE,
-          write_watcher_.get(),
-          this)) {
+          fd_.get().fd, false, base::MessageLoopForIO::WATCH_WRITE,
+          write_watcher_.get(), this)) {
     {
       base::AutoLock locker(write_lock());
 
       DCHECK(pending_write_);
       pending_write_ = false;
     }
     OnWriteCompleted(IO_FAILED_UNKNOWN, 0, 0);
   }
 }
 
 }  // namespace
 
 // -----------------------------------------------------------------------------
 
 // Static factory method declared in raw_channel.h.
 // static
 scoped_ptr<RawChannel> RawChannel::Create(
     embedder::ScopedPlatformHandle handle) {
   return make_scoped_ptr(new RawChannelPosix(handle.Pass()));
 }
 
 }  // namespace system
 }  // namespace mojo