Implement MojoGetBufferInformation(), part 1.

mojo/edk/system/dispatcher_unittest.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/dispatcher.h"
 
 #include <memory>
 #include <thread>
 #include <vector>
 
@@ skipping 56 matching lines @@
             d->BeginWriteData(NullUserPointer(), NullUserPointer(),
                               MOJO_WRITE_DATA_FLAG_NONE));
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, d->EndWriteData(0));
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
             d->ReadData(NullUserPointer(), NullUserPointer(),
                         MOJO_READ_DATA_FLAG_NONE));
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
             d->BeginReadData(NullUserPointer(), NullUserPointer(),
                              MOJO_READ_DATA_FLAG_NONE));
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, d->EndReadData(0));
+  RefPtr<Dispatcher> new_dispatcher;
+  EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
+            d->DuplicateBufferHandle(NullUserPointer(), &new_dispatcher));
+  EXPECT_FALSE(new_dispatcher);
+  EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
+            d->GetBufferInformation(NullUserPointer(), 0u));
+  std::unique_ptr<PlatformSharedBufferMapping> mapping;
+  EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
+            d->MapBuffer(0u, 1u, MOJO_MAP_BUFFER_FLAG_NONE, &mapping));
+  EXPECT_FALSE(mapping);
   Waiter w;
   w.Init();
   HandleSignalsState hss;
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
             d->AddAwakable(&w, ~MOJO_HANDLE_SIGNAL_NONE, 0, &hss));
   EXPECT_EQ(0u, hss.satisfied_signals);
   EXPECT_EQ(0u, hss.satisfiable_signals);
   // Okay to remove even if it wasn't added (or was already removed).
   hss = HandleSignalsState();
   d->RemoveAwakable(&w, &hss);
@@ skipping 19 matching lines @@
             d->BeginWriteData(NullUserPointer(), NullUserPointer(),
                               MOJO_WRITE_DATA_FLAG_NONE));
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, d->EndWriteData(0));
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
             d->ReadData(NullUserPointer(), NullUserPointer(),
                         MOJO_READ_DATA_FLAG_NONE));
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
             d->BeginReadData(NullUserPointer(), NullUserPointer(),
                              MOJO_READ_DATA_FLAG_NONE));
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, d->EndReadData(0));
+  new_dispatcher = nullptr;
+  EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
+            d->DuplicateBufferHandle(NullUserPointer(), &new_dispatcher));
+  EXPECT_FALSE(new_dispatcher);
+  EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
+            d->GetBufferInformation(NullUserPointer(), 0u));
+  mapping.reset();
+  EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
+            d->MapBuffer(0u, 1u, MOJO_MAP_BUFFER_FLAG_NONE, &mapping));
+  EXPECT_FALSE(mapping);
   hss = HandleSignalsState();
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
             d->AddAwakable(&w, ~MOJO_HANDLE_SIGNAL_NONE, 0, &hss));
   EXPECT_EQ(0u, hss.satisfied_signals);
   EXPECT_EQ(0u, hss.satisfiable_signals);
   hss = HandleSignalsState();
   d->RemoveAwakable(&w, &hss);
   EXPECT_EQ(0u, hss.satisfied_signals);
   EXPECT_EQ(0u, hss.satisfiable_signals);
 }
 
 enum class DispatcherOp {
   CLOSE = 0,
   WRITE_MESSAGE,
   READ_MESSAGE,
   WRITE_DATA,
   BEGIN_WRITE_DATA,
   END_WRITE_DATA,
   READ_DATA,
   BEGIN_READ_DATA,
   END_READ_DATA,
   DUPLICATE_BUFFER_HANDLE,
+  GET_BUFFER_INFORMATION,
   MAP_BUFFER,
-  ADD_WAITER,
-  REMOVE_WAITER,
+  ADD_AWAKABLE,
+  REMOVE_AWAKABLE,
   COUNT
 };
 
 void ThreadSafetyStressHelper(ManualResetWaitableEvent* event,
                               RefPtr<Dispatcher>&& dispatcher,
                               DispatcherOp op) {
   CHECK_LE(0, static_cast<int>(op));
   CHECK_LT(static_cast<int>(op), static_cast<int>(DispatcherOp::COUNT));
 
   event->Wait();
@@ skipping 38 matching lines @@
       break;
     case DispatcherOp::BEGIN_READ_DATA:
       EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
                 dispatcher->BeginReadData(NullUserPointer(), NullUserPointer(),
                                           MOJO_READ_DATA_FLAG_NONE));
       break;
     case DispatcherOp::END_READ_DATA:
       EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, dispatcher->EndReadData(0));
       break;
     case DispatcherOp::DUPLICATE_BUFFER_HANDLE: {
-      RefPtr<Dispatcher> unused;
+      RefPtr<Dispatcher> new_dispatcher;
       EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-                dispatcher->DuplicateBufferHandle(NullUserPointer(), &unused));
+                dispatcher->DuplicateBufferHandle(NullUserPointer(),
+                                                  &new_dispatcher));
+      EXPECT_FALSE(new_dispatcher);
       break;
     }
+    case DispatcherOp::GET_BUFFER_INFORMATION:
+      EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
+                dispatcher->GetBufferInformation(NullUserPointer(), 0u));
+      break;
     case DispatcherOp::MAP_BUFFER: {
-      std::unique_ptr<PlatformSharedBufferMapping> unused;
+      std::unique_ptr<PlatformSharedBufferMapping> mapping;
       EXPECT_EQ(
           MOJO_RESULT_INVALID_ARGUMENT,
-          dispatcher->MapBuffer(0u, 0u, MOJO_MAP_BUFFER_FLAG_NONE, &unused));
+          dispatcher->MapBuffer(0u, 1u, MOJO_MAP_BUFFER_FLAG_NONE, &mapping));
+      EXPECT_FALSE(mapping);
       break;
     }
-    case DispatcherOp::ADD_WAITER: {
+    case DispatcherOp::ADD_AWAKABLE: {
       HandleSignalsState hss;
       MojoResult r =
           dispatcher->AddAwakable(&waiter, ~MOJO_HANDLE_SIGNAL_NONE, 0, &hss);
       EXPECT_TRUE(r == MOJO_RESULT_FAILED_PRECONDITION ||
                   r == MOJO_RESULT_INVALID_ARGUMENT);
       EXPECT_EQ(0u, hss.satisfied_signals);
       EXPECT_EQ(0u, hss.satisfiable_signals);
       break;
     }
-    case DispatcherOp::REMOVE_WAITER: {
+    case DispatcherOp::REMOVE_AWAKABLE: {
       HandleSignalsState hss;
       dispatcher->RemoveAwakable(&waiter, &hss);
       EXPECT_EQ(0u, hss.satisfied_signals);
       EXPECT_EQ(0u, hss.satisfiable_signals);
       break;
     }
     default:
       NOTREACHED();
       break;
   }
@@ skipping 56 matching lines @@
     for (auto& thread : threads)
       thread.join();
 
     EXPECT_EQ(MOJO_RESULT_OK, d->Close());
   }
 }
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo