Support for process-wide incidents in the safe browsing incident reporting service.

chrome/browser/safe_browsing/delayed_callback_runner_unittest.cc

Index: chrome/browser/safe_browsing/delayed_callback_runner_unittest.cc
diff --git a/chrome/browser/safe_browsing/delayed_callback_runner_unittest.cc b/chrome/browser/safe_browsing/delayed_callback_runner_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..c1b4a7919c80feff22249bc6c85e6d9400376f6a
--- /dev/null
+++ b/chrome/browser/safe_browsing/delayed_callback_runner_unittest.cc
@@ -0,0 +1,160 @@
+// 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 "chrome/browser/safe_browsing/delayed_callback_runner.h"
+
+#include <map>
+#include <string>
+
+#include "base/callback.h"
+#include "base/macros.h"
+#include "base/test/test_simple_task_runner.h"
+#include "base/thread_task_runner_handle.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace {
+
+// A class of objects that invoke a callback upon destruction. This is used as
+// an owned argument on callbacks given to a DelayedCallbackRunner under test.
+class CallbackArgument {
+ public:
+  explicit CallbackArgument(const base::Closure& on_delete)
+      : on_delete_(on_delete) {}
+  ~CallbackArgument() { on_delete_.Run(); }
+
+ private:
+  base::Closure on_delete_;
+
+  DISALLOW_COPY_AND_ASSIGN(CallbackArgument);
+};
+
+}  // namespace
+
+// A test fixture that prepares a DelayedCallbackRunner instance for use and
+// tracks the lifecycle of callbacks sent to it.
+class DelayedCallbackRunnerTest : public testing::Test {
+ public:
+  // Registers a callback that will record its running and destruction to the
+  // test fixture under the given name.
+  void RegisterTestCallback(const std::string& name) {
+    callbacks_[name] = CallbackState();
+    instance_->RegisterCallback(MakeCallback(name));
+  }
+
+ protected:
+  DelayedCallbackRunnerTest()
+      : task_runner_(new base::TestSimpleTaskRunner),
+        thread_task_runner_handle_(task_runner_) {}
+
+  virtual void SetUp() OVERRIDE {
+    instance_.reset(new safe_browsing::DelayedCallbackRunner(
+        base::TimeDelta::FromMilliseconds(1),  // ignored by simple runner.
+        task_runner_));
+  }
+
+  virtual void TearDown() OVERRIDE { instance_.reset(); }
+
+  void OnRun(const std::string& name, CallbackArgument* arg) {
+    EXPECT_FALSE(callbacks_[name].run);
+    callbacks_[name].run = true;
+  }
+
+  void OnDelete(const std::string& name) {
+    EXPECT_FALSE(callbacks_[name].deleted);
+    callbacks_[name].deleted = true;
+  }
+
+  // Returns a callback argument that calls the test fixture's OnDelete method
+  // on behalf of the given callback name.
+  scoped_ptr<CallbackArgument> MakeCallbackArgument(const std::string& name) {
+    return make_scoped_ptr(new CallbackArgument(base::Bind(
+        &DelayedCallbackRunnerTest::OnDelete, base::Unretained(this), name)));
+  }
+
+  // Returns a closure that calls |OnRun| when run and |OnDelete| when deleted
+  // on behalf of the given callback name.
+  base::Closure MakeCallback(const std::string& name) {
+    return base::Bind(&DelayedCallbackRunnerTest::OnRun,
+                      base::Unretained(this),
+                      name,
+                      base::Owned(MakeCallbackArgument(name).release()));
+  }
+
+  bool CallbackWasRun(const std::string& name) { return callbacks_[name].run; }
+
+  bool CallbackWasDeleted(const std::string& name) {
+    return callbacks_[name].deleted;
+  }
+
+  scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
+  base::ThreadTaskRunnerHandle thread_task_runner_handle_;
+  scoped_ptr<safe_browsing::DelayedCallbackRunner> instance_;
+
+ private:
+  struct CallbackState {
+    CallbackState() : run(), deleted() {}
+    bool run;
+    bool deleted;
+  };
+
+  std::map<std::string, CallbackState> callbacks_;
+};
+
+// Tests that a callback is deleted when not run before the runner is destroyed.
+TEST_F(DelayedCallbackRunnerTest, NotRunDeleted) {
+  const std::string name("one");
+  RegisterTestCallback(name);
+  instance_.reset();
+  EXPECT_FALSE(CallbackWasRun(name));
+  EXPECT_TRUE(CallbackWasDeleted(name));
+}
+
+// Tests that a callback is run and deleted while the runner is alive.
+TEST_F(DelayedCallbackRunnerTest, RunDeleted) {
+  const std::string name("one");
+  RegisterTestCallback(name);
+  instance_->Start();
+  task_runner_->RunUntilIdle();
+  EXPECT_TRUE(CallbackWasRun(name));
+  EXPECT_TRUE(CallbackWasDeleted(name));
+}
+
+// Tests that a callback registered after Start() is called is also run and
+// deleted.
+TEST_F(DelayedCallbackRunnerTest, AddWhileRunningRun) {
+  const std::string name("one");
+  const std::string name2("two");
+
+  // Post a task to register a new callback after Start() is called.
+  task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&DelayedCallbackRunnerTest::RegisterTestCallback,
+                 base::Unretained(this),
+                 name2));
+
+  RegisterTestCallback(name);
+  instance_->Start();
+  task_runner_->RunUntilIdle();
+  EXPECT_TRUE(CallbackWasRun(name));
+  EXPECT_TRUE(CallbackWasDeleted(name));
+  EXPECT_TRUE(CallbackWasRun(name2));
+  EXPECT_TRUE(CallbackWasDeleted(name2));
+}
+
+TEST_F(DelayedCallbackRunnerTest, MultipleRuns) {
+  const std::string name("one");
+  const std::string name2("two");
+
+  RegisterTestCallback(name);
+  instance_->Start();
+  task_runner_->RunUntilIdle();
+  EXPECT_TRUE(CallbackWasRun(name));
+  EXPECT_TRUE(CallbackWasDeleted(name));
+
+  RegisterTestCallback(name2);
+  instance_->Start();
+  task_runner_->RunUntilIdle();
+  EXPECT_TRUE(CallbackWasRun(name2));
+  EXPECT_TRUE(CallbackWasDeleted(name2));
+}