Revert of Update mojo sdk to rev afb4440fd5a10cba980878c326180b7ad7960480

mojo/edk/system/raw_channel_win.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 <windows.h>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
@@ skipping 353 matching lines @@
 
 RawChannel::IOResult RawChannelWin::Read(size_t* bytes_read) {
   DCHECK_EQ(base::MessageLoop::current(), message_loop_for_io());
   DCHECK(io_handler_);
   DCHECK(!io_handler_->pending_read());
 
   char* buffer = nullptr;
   size_t bytes_to_read = 0;
   read_buffer()->GetBuffer(&buffer, &bytes_to_read);
 
-  BOOL result =
-      ReadFile(io_handler_->handle(), buffer, static_cast<DWORD>(bytes_to_read),
-               nullptr, &io_handler_->read_context()->overlapped);
+  BOOL result = ReadFile(io_handler_->handle(),
+                         buffer,
+                         static_cast<DWORD>(bytes_to_read),
+                         nullptr,
+                         &io_handler_->read_context()->overlapped);
   if (!result) {
     DWORD error = GetLastError();
     if (error == ERROR_BROKEN_PIPE)
       return IO_FAILED_SHUTDOWN;
     if (error != ERROR_IO_PENDING) {
       LOG(WARNING) << "ReadFile: " << logging::SystemErrorCodeToString(error);
       return IO_FAILED_UNKNOWN;
     }
   }
 
   if (result && skip_completion_port_on_success_) {
     DWORD bytes_read_dword = 0;
-    BOOL get_size_result = GetOverlappedResult(
-        io_handler_->handle(), &io_handler_->read_context()->overlapped,
-        &bytes_read_dword, FALSE);
+    BOOL get_size_result =
+        GetOverlappedResult(io_handler_->handle(),
+                            &io_handler_->read_context()->overlapped,
+                            &bytes_read_dword,
+                            FALSE);
     DPCHECK(get_size_result);
     *bytes_read = bytes_read_dword;
     return IO_SUCCEEDED;
   }
 
   // If the read is pending or the read has succeeded but we don't skip
   // completion port on success, instruct |io_handler_| to wait for the
   // completion packet.
   //
   // TODO(yzshen): It seems there isn't document saying that all error cases
@@ skipping 13 matching lines @@
   size_t bytes_read = 0;
   IOResult io_result = Read(&bytes_read);
   if (io_result == IO_SUCCEEDED) {
     DCHECK(skip_completion_port_on_success_);
 
     // We have finished reading successfully. Queue a notification manually.
     io_handler_->OnPendingReadStarted();
     // |io_handler_| won't go away before the task is run, so it is safe to use
     // |base::Unretained()|.
     message_loop_for_io()->PostTask(
-        FROM_HERE, base::Bind(&RawChannelIOHandler::OnIOCompleted,
-                              base::Unretained(io_handler_),
-                              base::Unretained(io_handler_->read_context()),
-                              static_cast<DWORD>(bytes_read), ERROR_SUCCESS));
+        FROM_HERE,
+        base::Bind(&RawChannelIOHandler::OnIOCompleted,
+                   base::Unretained(io_handler_),
+                   base::Unretained(io_handler_->read_context()),
+                   static_cast<DWORD>(bytes_read),
+                   ERROR_SUCCESS));
     return IO_PENDING;
   }
 
   return io_result;
 }
 
 embedder::ScopedPlatformHandleVectorPtr RawChannelWin::GetReadPlatformHandles(
     size_t num_platform_handles,
     const void* platform_handle_table) {
   // TODO(vtl): Implement.
@@ skipping 13 matching lines @@
     // TODO(vtl): Implement.
     NOTIMPLEMENTED();
   }
 
   std::vector<WriteBuffer::Buffer> buffers;
   write_buffer_no_lock()->GetBuffers(&buffers);
   DCHECK(!buffers.empty());
 
   // TODO(yzshen): Handle multi-segment writes more efficiently.
   DWORD bytes_written_dword = 0;
-  BOOL result =
-      WriteFile(io_handler_->handle(), buffers[0].addr,
-                static_cast<DWORD>(buffers[0].size), &bytes_written_dword,
-                &io_handler_->write_context_no_lock()->overlapped);
+  BOOL result = WriteFile(io_handler_->handle(),
+                          buffers[0].addr,
+                          static_cast<DWORD>(buffers[0].size),
+                          &bytes_written_dword,
+                          &io_handler_->write_context_no_lock()->overlapped);
   if (!result) {
     DWORD error = GetLastError();
     if (error == ERROR_BROKEN_PIPE)
       return IO_FAILED_SHUTDOWN;
     if (error != ERROR_IO_PENDING) {
       LOG(WARNING) << "WriteFile: " << logging::SystemErrorCodeToString(error);
       return IO_FAILED_UNKNOWN;
     }
   }
 
@@ skipping 31 matching lines @@
 
     // We have finished writing successfully. Queue a notification manually.
     io_handler_->OnPendingWriteStartedNoLock();
     // |io_handler_| won't go away before that task is run, so it is safe to use
     // |base::Unretained()|.
     message_loop_for_io()->PostTask(
         FROM_HERE,
         base::Bind(&RawChannelIOHandler::OnIOCompleted,
                    base::Unretained(io_handler_),
                    base::Unretained(io_handler_->write_context_no_lock()),
-                   static_cast<DWORD>(bytes_written), ERROR_SUCCESS));
+                   static_cast<DWORD>(bytes_written),
+                   ERROR_SUCCESS));
     return IO_PENDING;
   }
 
   return io_result;
 }
 
 bool RawChannelWin::OnInit() {
   DCHECK_EQ(base::MessageLoop::current(), message_loop_for_io());
 
   DCHECK(handle_.is_valid());
@@ skipping 40 matching lines @@
 
 // Static factory method declared in raw_channel.h.
 // static
 scoped_ptr<RawChannel> RawChannel::Create(
     embedder::ScopedPlatformHandle handle) {
   return make_scoped_ptr(new RawChannelWin(handle.Pass()));
 }
 
 }  // namespace system
 }  // namespace mojo