Make the new Mojo EDK work on XP.

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/bind.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/process/process.h"
 #include "base/synchronization/lock.h"
+#include "base/synchronization/waitable_event.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/windows_version.h"
 #include "mojo/edk/embedder/embedder_internal.h"
 #include "mojo/edk/embedder/platform_handle.h"
 #include "mojo/edk/system/transport_data.h"
 #include "mojo/public/cpp/system/macros.h"
 
 #define STATUS_CANCELLED 0xC0000120
 #define STATUS_PIPE_BROKEN 0xC000014B
 
@@ skipping 48 matching lines @@
       HANDLE, FILE_INFO_BY_HANDLE_CLASS, LPVOID, DWORD);
 
   bool is_vista_or_higher_;
   CancelIoExFunc cancel_io_ex_;
   GetFileInformationByHandleExFunc get_file_information_by_handle_ex_;
 };
 
 base::LazyInstance<VistaOrHigherFunctions> g_vista_or_higher_functions =
     LAZY_INSTANCE_INITIALIZER;
 
+void CancelOnIO(HANDLE handle, base::WaitableEvent* event) {
+  CancelIo(handle);
+  event->Signal();
+}
+
 class RawChannelWin final : public RawChannel {
  public:
   RawChannelWin(ScopedPlatformHandle handle)
       : handle_(handle.Pass()), io_handler_(nullptr) {
     DCHECK(handle_.is_valid());
   }
   ~RawChannelWin() override {
     DCHECK(!io_handler_);
   }
 
@@ skipping 128 matching lines @@
       owner_ = nullptr;
       if (ShouldSelfDestruct())
         delete this;
     }
 
     ScopedPlatformHandle ReleaseHandle(
         std::vector<char>* serialized_read_buffer,
         std::vector<char>* serialized_write_buffer,
         bool* write_error) {
       // Cancel pending IO calls.
+      bool is_xp = false;
       if (g_vista_or_higher_functions.Get().is_vista_or_higher()) {
         g_vista_or_higher_functions.Get().CancelIoEx(handle(), nullptr);
       } else {
-        CHECK(false) << "TODO(jam): handle XP";
+        is_xp = true;
+        if (pending_read_) {
+          if (internal::g_io_thread_task_runner->RunsTasksOnCurrentThread()) {
+            CancelIo(handle());
+          } else {
+            base::WaitableEvent event(false, false);
+            internal::g_io_thread_task_runner->PostTask(
+                FROM_HERE,
+                base::Bind(&CancelOnIO, handle(), &event));
+            event.Wait();
+          }
+        }
       }
 
       size_t additional_bytes_read = 0;
       bool got_read_error = false;
       if (pending_read_) {
         bool wait = false;
         UnregisterWaitEx(read_wait_object_, INVALID_HANDLE_VALUE);
         read_wait_object_ = NULL;
         if (!read_event_signalled_)
           wait = true;
@@ skipping 16 matching lines @@
         }
         pending_read_ = false;
       }
 
       RawChannel::WriteBuffer* write_buffer = owner_->write_buffer_no_lock();
 
       size_t additional_bytes_written = 0;
       size_t additional_platform_handles_written = 0;
       *write_error = owner_->pending_write_error();
       if (pending_write_) {
-        bool wait = false;
+        // If we had a pending write, then on XP we just wait till it completes.
+        // We use limited size buffers, so Windows should always find paged pool
+        // memory to finish the writes.
+        // TODO(jam): use background thread to verify that we don't hang here?
+        bool wait = is_xp;
         UnregisterWaitEx(write_wait_object_, INVALID_HANDLE_VALUE);
         write_wait_object_ = NULL;
         if (!write_event_signalled_)
           wait = true;
 
         DWORD bytes_written_dword = 0;
 
         // See comment above.
         BOOL rv = GetOverlappedResult(
             handle(), &write_context_.overlapped, &bytes_written_dword,
@@ skipping 486 matching lines @@
     FILE_NAME_INFO* fileinfo1 = reinterpret_cast<FILE_NAME_INFO *>(data1);
     FILE_NAME_INFO* fileinfo2 = reinterpret_cast<FILE_NAME_INFO *>(data2);
     CHECK(g_vista_or_higher_functions.Get().GetFileInformationByHandleEx(
         this_handle.handle, FileNameInfo, fileinfo1, arraysize(data1)));
     CHECK(g_vista_or_higher_functions.Get().GetFileInformationByHandleEx(
         other_handle.handle, FileNameInfo, fileinfo2, arraysize(data2)));
     std::wstring filepath1(fileinfo1->FileName, fileinfo1->FileNameLength / 2);
     std::wstring filepath2(fileinfo2->FileName, fileinfo2->FileNameLength / 2);
     return filepath1 == filepath2;
   } else {
-    // TODO: XP: see http://stackoverflow.com/questions/65170/how-to-get-name-associated-with-open-handle/5286888#5286888
-    CHECK(false) << "TODO(jam): handle XP";
+    // This is to catch developer errors. Let them be caught on Vista and above,
+    // i.e. no point in implementing this on XP since support for it will be
+    // removed in early 2016.
     return false;
   }
 }
 
 }  // namespace edk
 }  // namespace mojo