Update mojo sdk to rev e01f9a49449381a5eb430c1fd88bf2cae73ec35a

mojo/edk/embedder/simple_platform_shared_buffer_win.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/embedder/simple_platform_shared_buffer.h"
 
 #include <windows.h>
 
 #include <limits>
 
@@ skipping 15 matching lines @@
       static_cast<uint64_t>(std::numeric_limits<DWORD>::max())) {
     return false;
   }
 
   // IMPORTANT NOTE: Unnamed objects are NOT SECURABLE. Thus if we ever want to
   // share read-only to other processes, we'll have to name our file mapping
   // object.
   // TODO(vtl): Unlike |base::SharedMemory|, we don't round up the size (to a
   // multiple of 64 KB). This may cause problems with NaCl. Cross this bridge
   // when we get there. crbug.com/210609
-  handle_.reset(PlatformHandle(CreateFileMapping(INVALID_HANDLE_VALUE,
-                                                 nullptr,
-                                                 PAGE_READWRITE,
-                                                 0,
-                                                 static_cast<DWORD>(num_bytes_),
-                                                 nullptr)));
+  handle_.reset(PlatformHandle(
+      CreateFileMapping(INVALID_HANDLE_VALUE, nullptr, PAGE_READWRITE, 0,
+                        static_cast<DWORD>(num_bytes_), nullptr)));
   if (!handle_.is_valid()) {
     PLOG(ERROR) << "CreateFileMapping";
     return false;
   }
 
   return true;
 }
 
 bool SimplePlatformSharedBuffer::InitFromPlatformHandle(
     ScopedPlatformHandle platform_handle) {
   DCHECK(!handle_.is_valid());
 
   // TODO(vtl): Implement.
   NOTIMPLEMENTED();
   return false;
 }
 
 scoped_ptr<PlatformSharedBufferMapping> SimplePlatformSharedBuffer::MapImpl(
     size_t offset,
     size_t length) {
   size_t offset_rounding = offset % base::SysInfo::VMAllocationGranularity();
   size_t real_offset = offset - offset_rounding;
   size_t real_length = length + offset_rounding;
 
   // This should hold (since we checked |num_bytes| versus the maximum value of
   // |off_t| on creation, but it never hurts to be paranoid.
   DCHECK_LE(static_cast<uint64_t>(real_offset),
             static_cast<uint64_t>(std::numeric_limits<DWORD>::max()));
 
-  void* real_base = MapViewOfFile(handle_.get().handle,
-                                  FILE_MAP_READ | FILE_MAP_WRITE,
-                                  0,
-                                  static_cast<DWORD>(real_offset),
-                                  real_length);
+  void* real_base =
+      MapViewOfFile(handle_.get().handle, FILE_MAP_READ | FILE_MAP_WRITE, 0,
+                    static_cast<DWORD>(real_offset), real_length);
   if (!real_base) {
     PLOG(ERROR) << "MapViewOfFile";
     return nullptr;
   }
 
   void* base = static_cast<char*>(real_base) + offset_rounding;
   return make_scoped_ptr(new SimplePlatformSharedBufferMapping(
       base, length, real_base, real_length));
 }
 
 // SimplePlatformSharedBufferMapping -------------------------------------------
 
 void SimplePlatformSharedBufferMapping::Unmap() {
   BOOL result = UnmapViewOfFile(real_base_);
   PLOG_IF(ERROR, !result) << "UnmapViewOfFile";
 }
 
 }  // namespace embedder
 }  // namespace mojo