Fix a bunch of mojo_public_*_unittests with the new EDK.

mojo/public/cpp/bindings/tests/union_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 <stddef.h>
 #include <stdint.h>
 #include <utility>
 #include <vector>
 
 #include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
 #include "mojo/message_pump/message_pump_mojo.h"
 #include "mojo/public/cpp/bindings/array.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "mojo/public/cpp/bindings/lib/array_internal.h"
 #include "mojo/public/cpp/bindings/lib/array_serialization.h"
 #include "mojo/public/cpp/bindings/lib/bounds_checker.h"
 #include "mojo/public/cpp/bindings/lib/fixed_buffer.h"
 #include "mojo/public/cpp/bindings/string.h"
 #include "mojo/public/cpp/test_support/test_utils.h"
 #include "mojo/public/interfaces/bindings/tests/test_structs.mojom.h"
@@ skipping 1022 matching lines @@
   void* raw_buf = buf.Leak();
   mojo::internal::BoundsChecker bounds_checker(data,
                                                static_cast<uint32_t>(size), 1);
   EXPECT_FALSE(
       internal::HandleUnion_Data::Validate(raw_buf, &bounds_checker, false));
   free(raw_buf);
 }
 
 class SmallCacheImpl : public SmallCache {
  public:
-  SmallCacheImpl() : int_value_(0) {}
+  explicit SmallCacheImpl(const base::Closure& closure)
+      : int_value_(0), closure_(closure) {}
   ~SmallCacheImpl() override {}
   int64_t int_value() const { return int_value_; }
 
  private:
-  void SetIntValue(int64_t int_value) override { int_value_ = int_value; }
+  void SetIntValue(int64_t int_value) override {
+    int_value_ = int_value;
+    closure_.Run();
+  }
   void GetIntValue(const GetIntValueCallback& callback) override {
     callback.Run(int_value_);
   }
 
   int64_t int_value_;
+  base::Closure closure_;
 };
 
 TEST(UnionTest, InterfaceInUnion) {
-  base::MessageLoop run_loop(common::MessagePumpMojo::Create());
-  SmallCacheImpl impl;
+  base::MessageLoop message_loop(common::MessagePumpMojo::Create());
+  base::RunLoop run_loop;
+  SmallCacheImpl impl(run_loop.QuitClosure());
   SmallCachePtr ptr;
   Binding<SmallCache> bindings(&impl, GetProxy(&ptr));
 
   HandleUnionPtr handle(HandleUnion::New());
   handle->set_f_small_cache(std::move(ptr));
 
   handle->get_f_small_cache()->SetIntValue(10);
-  run_loop.RunUntilIdle();
+  run_loop.Run();
   EXPECT_EQ(10, impl.int_value());
 }
 
 TEST(UnionTest, InterfaceInUnionSerialization) {
-  base::MessageLoop run_loop(common::MessagePumpMojo::Create());
-  SmallCacheImpl impl;
+  base::MessageLoop message_loop(common::MessagePumpMojo::Create());
+  base::RunLoop run_loop;
+  SmallCacheImpl impl(run_loop.QuitClosure());
   SmallCachePtr ptr;
   Binding<SmallCache> bindings(&impl, GetProxy(&ptr));
 
   HandleUnionPtr handle(HandleUnion::New());
   handle->set_f_small_cache(std::move(ptr));
   size_t size = GetSerializedSize_(handle, false);
   EXPECT_EQ(16U, size);
 
   mojo::internal::FixedBufferForTesting buf(size);
   internal::HandleUnion_Data* data = nullptr;
   SerializeUnion_(std::move(handle), &buf, &data, false);
 
   std::vector<Handle> handles;
   data->EncodePointersAndHandles(&handles);
   EXPECT_EQ(1U, handles.size());
   data->DecodePointersAndHandles(&handles);
 
   HandleUnionPtr handle2(HandleUnion::New());
   Deserialize_(data, &handle2, nullptr);
 
   handle2->get_f_small_cache()->SetIntValue(10);
-  run_loop.RunUntilIdle();
+  run_loop.Run();
   EXPECT_EQ(10, impl.int_value());
 }
 
 class UnionInterfaceImpl : public UnionInterface {
  public:
   UnionInterfaceImpl() {}
   ~UnionInterfaceImpl() override {}
 
  private:
   void Echo(PodUnionPtr in, const EchoCallback& callback) override {
@@ skipping 10 matching lines @@
   PodUnionPtr pod(PodUnion::New());
   pod->set_f_int16(16);
 
   ptr->Echo(std::move(pod),
             [](PodUnionPtr out) { EXPECT_EQ(16, out->get_f_int16()); });
   run_loop.RunUntilIdle();
 }
 
 }  // namespace test
 }  // namespace mojo