Update from https://crrev.com/302630

net/base/test_completion_callback_unittest.cc

 // Copyright (c) 2011 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.
 
 // Illustrates how to use worker threads that issue completion callbacks
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/threading/worker_pool.h"
 #include "net/base/completion_callback.h"
 #include "net/base/test_completion_callback.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
-typedef PlatformTest TestCompletionCallbackTest;
+namespace {
 
 const int kMagicResult = 8888;
 
+void CallClosureAfterCheckingResult(const base::Closure& closure,
+                                    bool* did_check_result,
+                                    int result) {
+  DCHECK_EQ(result, kMagicResult);
+  *did_check_result = true;
+  closure.Run();
+}
+
 // ExampleEmployer is a toy version of HostResolver
 // TODO: restore damage done in extracting example from real code
 // (e.g. bring back real destructor, bring back comments)
 class ExampleEmployer {
  public:
   ExampleEmployer();
   ~ExampleEmployer();
 
   // Do some imaginary work on a worker thread;
   // when done, worker posts callback on the original thread.
@@ skipping 74 matching lines @@
           base::Bind(&ExampleWorker::DoWork, request_.get()),
           true)) {
     NOTREACHED();
     request_ = NULL;
     return false;
   }
 
   return true;
 }
 
+}  // namespace
+
+typedef PlatformTest TestCompletionCallbackTest;
+
 TEST_F(TestCompletionCallbackTest, Simple) {
   ExampleEmployer boss;
   net::TestCompletionCallback callback;
   bool queued = boss.DoSomething(callback.callback());
-  EXPECT_EQ(queued, true);
+  EXPECT_TRUE(queued);
   int result = callback.WaitForResult();
   EXPECT_EQ(result, kMagicResult);
 }
 
+TEST_F(TestCompletionCallbackTest, Closure) {
+  ExampleEmployer boss;
+  net::TestClosure closure;
+  bool did_check_result = false;
+  net::CompletionCallback completion_callback =
+      base::Bind(&CallClosureAfterCheckingResult,
+                 closure.closure(), base::Unretained(&did_check_result));
+  bool queued = boss.DoSomething(completion_callback);
+  EXPECT_TRUE(queued);
+
+  EXPECT_FALSE(did_check_result);
+  closure.WaitForResult();
+  EXPECT_TRUE(did_check_result);
+}
+
 // TODO: test deleting ExampleEmployer while work outstanding