Revert of Remove MessageLoop destruction observer from mojo::Watcher.

mojo/public/cpp/system/tests/watcher_unittest.cc

 // Copyright 2016 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/system/watcher.h"
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/callback.h"
-#include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "mojo/public/c/system/types.h"
 #include "mojo/public/cpp/system/message_pipe.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace {
 
 template <typename Handler>
 void RunResultHandler(Handler f, MojoResult result) { f(result); }
 
 template <typename Handler>
 Watcher::ReadyCallback OnReady(Handler f) {
   return base::Bind(&RunResultHandler<Handler>, f);
 }
 
 Watcher::ReadyCallback NotReached() {
   return OnReady([] (MojoResult) { NOTREACHED(); });
 }
 
 class WatcherTest : public testing::Test {
  public:
   WatcherTest() {}
   ~WatcherTest() override {}
 
- private:
-  base::MessageLoop message_loop_;
+  void SetUp() override {
+    message_loop_.reset(new base::MessageLoop);
+  }
 
-  DISALLOW_COPY_AND_ASSIGN(WatcherTest);
+  void TearDown() override {
+    message_loop_.reset();
+  }
+
+ protected:
+  std::unique_ptr<base::MessageLoop> message_loop_;
 };
 
 TEST_F(WatcherTest, WatchBasic) {
   ScopedMessagePipeHandle a, b;
   CreateMessagePipe(nullptr, &a, &b);
 
   bool notified = false;
   base::RunLoop run_loop;
   Watcher b_watcher;
   EXPECT_EQ(MOJO_RESULT_OK,
@@ skipping 97 matching lines @@
   }
 
   // This should never trigger the watcher above.
   EXPECT_EQ(MOJO_RESULT_OK, WriteMessageRaw(a.get(), "hello", 5, nullptr, 0,
                                             MOJO_WRITE_MESSAGE_FLAG_NONE));
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, run_loop.QuitClosure());
   run_loop.Run();
 }
 
+TEST_F(WatcherTest, NotifyOnMessageLoopDestruction) {
+  ScopedMessagePipeHandle a, b;
+  CreateMessagePipe(nullptr, &a, &b);
+
+  bool notified = false;
+  Watcher b_watcher;
+  EXPECT_EQ(MOJO_RESULT_OK,
+            b_watcher.Start(b.get(), MOJO_HANDLE_SIGNAL_READABLE,
+                            OnReady([&] (MojoResult result) {
+                              EXPECT_EQ(MOJO_RESULT_ABORTED, result);
+                              notified = true;
+                            })));
+  EXPECT_TRUE(b_watcher.IsWatching());
+
+  message_loop_.reset();
+
+  EXPECT_TRUE(notified);
+
+  EXPECT_TRUE(b_watcher.IsWatching());
+  b_watcher.Cancel();
+}
+
 TEST_F(WatcherTest, CloseAndCancel) {
   ScopedMessagePipeHandle a, b;
   CreateMessagePipe(nullptr, &a, &b);
 
   Watcher b_watcher;
   EXPECT_EQ(MOJO_RESULT_OK,
             b_watcher.Start(b.get(), MOJO_HANDLE_SIGNAL_READABLE,
                             OnReady([](MojoResult result) { FAIL(); })));
   EXPECT_TRUE(b_watcher.IsWatching());
 
   // This should trigger the watcher above...
   b.reset();
   // ...but the watcher is cancelled first.
   b_watcher.Cancel();
 
   EXPECT_FALSE(b_watcher.IsWatching());
 
   base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace
 }  // namespace mojo