Update mojo sdk to rev f6c8ec07c01deebc13178d516225fd12695c3dc2

mojo/public/cpp/utility/tests/run_loop_unittest.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/public/cpp/utility/run_loop.h"
 
 #include <string>
 
 #include "mojo/public/cpp/system/core.h"
 #include "mojo/public/cpp/test_support/test_utils.h"
@@ skipping 53 matching lines @@
 };
 
 // Trivial test to verify Run() with no added handles returns.
 TEST_F(RunLoopTest, ExitsWithNoHandles) {
   RunLoop run_loop;
   run_loop.Run();
 }
 
 class RemoveOnReadyRunLoopHandler : public TestRunLoopHandler {
  public:
-  RemoveOnReadyRunLoopHandler() : run_loop_(NULL) {
-  }
+  RemoveOnReadyRunLoopHandler() : run_loop_(nullptr) {}
   ~RemoveOnReadyRunLoopHandler() override {}
 
   void set_run_loop(RunLoop* run_loop) { run_loop_ = run_loop; }
 
   // RunLoopHandler:
   void OnHandleReady(const Handle& handle) override {
     run_loop_->RemoveHandler(handle);
     TestRunLoopHandler::OnHandleReady(handle);
   }
 
@@ skipping 14 matching lines @@
   run_loop.AddHandler(&handler, test_pipe.handle0.get(),
                       MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE);
   run_loop.Run();
   EXPECT_EQ(1, handler.ready_count());
   EXPECT_EQ(0, handler.error_count());
   EXPECT_FALSE(run_loop.HasHandler(test_pipe.handle0.get()));
 }
 
 class QuitOnReadyRunLoopHandler : public TestRunLoopHandler {
  public:
-  QuitOnReadyRunLoopHandler() : run_loop_(NULL) {
-  }
+  QuitOnReadyRunLoopHandler() : run_loop_(nullptr) {}
   ~QuitOnReadyRunLoopHandler() override {}
 
   void set_run_loop(RunLoop* run_loop) { run_loop_ = run_loop; }
 
   // RunLoopHandler:
   void OnHandleReady(const Handle& handle) override {
     run_loop_->Quit();
     TestRunLoopHandler::OnHandleReady(handle);
   }
 
@@ skipping 14 matching lines @@
   run_loop.AddHandler(&handler, test_pipe.handle0.get(),
                       MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE);
   run_loop.Run();
   EXPECT_EQ(1, handler.ready_count());
   EXPECT_EQ(0, handler.error_count());
   EXPECT_TRUE(run_loop.HasHandler(test_pipe.handle0.get()));
 }
 
 class QuitOnErrorRunLoopHandler : public TestRunLoopHandler {
  public:
-  QuitOnErrorRunLoopHandler() : run_loop_(NULL) {
-  }
+  QuitOnErrorRunLoopHandler() : run_loop_(nullptr) {}
   ~QuitOnErrorRunLoopHandler() override {}
 
   void set_run_loop(RunLoop* run_loop) { run_loop_ = run_loop; }
 
   // RunLoopHandler:
   void OnHandleError(const Handle& handle, MojoResult result) override {
     run_loop_->Quit();
     TestRunLoopHandler::OnHandleError(handle, result);
   }
 
@@ skipping 29 matching lines @@
                         test_pipe.handle0.get(),
                         MOJO_HANDLE_SIGNAL_READABLE,
                         MOJO_DEADLINE_INDEFINITE);
   }
   EXPECT_EQ(1, handler.error_count());
   EXPECT_EQ(MOJO_RESULT_ABORTED, handler.last_error_result());
 }
 
 class RemoveManyRunLoopHandler : public TestRunLoopHandler {
  public:
-  RemoveManyRunLoopHandler() : run_loop_(NULL) {
-  }
+  RemoveManyRunLoopHandler() : run_loop_(nullptr) {}
   ~RemoveManyRunLoopHandler() override {}
 
   void set_run_loop(RunLoop* run_loop) { run_loop_ = run_loop; }
   void add_handle(const Handle& handle) { handles_.push_back(handle); }
 
   // RunLoopHandler:
   void OnHandleError(const Handle& handle, MojoResult result) override {
     for (size_t i = 0; i < handles_.size(); i++)
       run_loop_->RemoveHandler(handles_[i]);
     TestRunLoopHandler::OnHandleError(handle, result);
@@ skipping 30 matching lines @@
                         MOJO_DEADLINE_INDEFINITE);
   }
   EXPECT_EQ(1, odd_handler.error_count());
   EXPECT_EQ(1, even_handler.error_count());
   EXPECT_EQ(MOJO_RESULT_ABORTED, odd_handler.last_error_result());
   EXPECT_EQ(MOJO_RESULT_ABORTED, even_handler.last_error_result());
 }
 
 class AddHandlerOnErrorHandler : public TestRunLoopHandler {
  public:
-  AddHandlerOnErrorHandler() : run_loop_(NULL) {
-  }
+  AddHandlerOnErrorHandler() : run_loop_(nullptr) {}
   ~AddHandlerOnErrorHandler() override {}
 
   void set_run_loop(RunLoop* run_loop) { run_loop_ = run_loop; }
 
   // RunLoopHandler:
   void OnHandleError(const Handle& handle, MojoResult result) override {
     run_loop_->AddHandler(this, handle,
                           MOJO_HANDLE_SIGNAL_READABLE,
                           MOJO_DEADLINE_INDEFINITE);
     TestRunLoopHandler::OnHandleError(handle, result);
@@ skipping 14 matching lines @@
     run_loop.AddHandler(&handler,
                         test_pipe.handle0.get(),
                         MOJO_HANDLE_SIGNAL_READABLE,
                         MOJO_DEADLINE_INDEFINITE);
   }
   EXPECT_EQ(1, handler.error_count());
   EXPECT_EQ(MOJO_RESULT_ABORTED, handler.last_error_result());
 }
 
 TEST_F(RunLoopTest, Current) {
-  EXPECT_TRUE(RunLoop::current() == NULL);
+  EXPECT_TRUE(RunLoop::current() == nullptr);
   {
     RunLoop run_loop;
     EXPECT_EQ(&run_loop, RunLoop::current());
   }
-  EXPECT_TRUE(RunLoop::current() == NULL);
+  EXPECT_TRUE(RunLoop::current() == nullptr);
 }
 
 class NestingRunLoopHandler : public TestRunLoopHandler {
  public:
   static const size_t kDepthLimit;
   static const char kSignalMagic;
 
   NestingRunLoopHandler()
-      : run_loop_(NULL),
-        pipe_(NULL),
+      : run_loop_(nullptr),
+        pipe_(nullptr),
         depth_(0),
         reached_depth_limit_(false) {}
 
   ~NestingRunLoopHandler() override {}
 
   void set_run_loop(RunLoop* run_loop) { run_loop_ = run_loop; }
   void set_pipe(MessagePipe* pipe) { pipe_ = pipe; }
   bool reached_depth_limit() const { return reached_depth_limit_; }
 
   // RunLoopHandler:
@@ skipping 17 matching lines @@
     } else {
       EXPECT_EQ(current_depth, kDepthLimit);
       reached_depth_limit_ = true;
       run_loop_->Quit();
     }
     --depth_;
   }
 
   void WriteSignal() {
     char write_byte = kSignalMagic;
-    MojoResult write_result = WriteMessageRaw(
-        pipe_->handle1.get(),
-        &write_byte, 1, NULL, 0, MOJO_WRITE_MESSAGE_FLAG_NONE);
+    MojoResult write_result =
+        WriteMessageRaw(pipe_->handle1.get(), &write_byte, 1, nullptr, 0,
+                        MOJO_WRITE_MESSAGE_FLAG_NONE);
     EXPECT_EQ(write_result, MOJO_RESULT_OK);
   }
 
   void ReadSignal() {
     char read_byte = 0;
     uint32_t bytes_read = 1;
     uint32_t handles_read = 0;
-    MojoResult read_result = ReadMessageRaw(
-        pipe_->handle0.get(),
-        &read_byte, &bytes_read, NULL, &handles_read,
-        MOJO_READ_MESSAGE_FLAG_NONE);
+    MojoResult read_result =
+        ReadMessageRaw(pipe_->handle0.get(), &read_byte, &bytes_read, nullptr,
+                       &handles_read, MOJO_READ_MESSAGE_FLAG_NONE);
     EXPECT_EQ(read_result, MOJO_RESULT_OK);
     EXPECT_EQ(read_byte, kSignalMagic);
   }
 
  private:
   RunLoop* run_loop_;
   MessagePipe* pipe_;
   size_t depth_;
   bool reached_depth_limit_;
 
@@ skipping 60 matching lines @@
   run_loop.AddHandler(&handler,
                       test_pipe.handle0.get(),
                       MOJO_HANDLE_SIGNAL_READABLE,
                       MOJO_DEADLINE_INDEFINITE);
   run_loop.PostDelayedTask(Closure(QuittingTask(&run_loop)), 0);
   run_loop.Run();
 }
 
 }  // namespace
 }  // namespace mojo