Don't abuse LevelDBObserver interface to pass GetAll result.

content/browser/leveldb_wrapper_impl_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 "content/browser/leveldb_wrapper_impl.h"
 
 #include "base/run_loop.h"
 #include "components/leveldb/public/cpp/util.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "mojo/public/cpp/bindings/associated_binding.h"
+#include "mojo/public/cpp/bindings/strong_associated_binding.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using leveldb::StdStringToUint8Vector;
 using leveldb::Uint8VectorToStdString;
 
 namespace content {
 
 namespace {
 
 const char* kTestPrefix = "abc";
@@ skipping 135 matching lines @@
 
   void IteratorPrev(const base::UnguessableToken& iterator,
                     const IteratorPrevCallback& callback) override {
     FAIL();
   }
 
  private:
   std::map<std::vector<uint8_t>, std::vector<uint8_t>>& mock_data_;
 };
 
+class GetAllCallback : public mojom::LevelDBWrapperGetAllCallback {
+ public:
+  static mojom::LevelDBWrapperGetAllCallbackAssociatedPtrInfo CreateAndBind(
+      mojo::AssociatedGroup* associated_group,
+      bool* result,
+      const base::Closure& callback) {
+    mojom::LevelDBWrapperGetAllCallbackAssociatedPtrInfo ptr_info;
+    mojom::LevelDBWrapperGetAllCallbackAssociatedRequest request;
+    associated_group->CreateAssociatedInterface(
+        mojo::AssociatedGroup::WILL_PASS_PTR, &ptr_info, &request);
+    mojo::MakeStrongAssociatedBinding(
+        base::WrapUnique(new GetAllCallback(result, callback)),
+        std::move(request));
+    return ptr_info;
+  }
+
+ private:
+  GetAllCallback(bool* result, const base::Closure& callback)
+      : m_result(result), m_callback(callback) {}
+  void Complete(bool success) override {
+    *m_result = success;
+    m_callback.Run();
+  }
+
+  bool* m_result;
+  base::Closure m_callback;
+};
+
 void NoOp() {}
 
 void GetCallback(const base::Closure& callback,
                  bool* success_out,
                  std::vector<uint8_t>* value_out,
                  bool success,
                  const std::vector<uint8_t>& value) {
   *success_out = success;
   *value_out = value;
   callback.Run();
@@ skipping 28 matching lines @@
                           10 * 1024 * 1024 /* max_bytes_per_hour */,
                           60 /* max_commits_per_hour */,
                           base::Bind(&NoOp)),
         observer_binding_(this) {
     set_mock_data(std::string(kTestPrefix) + "def", "defdata");
     set_mock_data(std::string(kTestPrefix) + "123", "123data");
     set_mock_data("123", "baddata");
 
     level_db_wrapper_.Bind(mojo::MakeRequest(&level_db_wrapper_ptr_));
     mojom::LevelDBObserverAssociatedPtrInfo ptr_info;
-    observer_binding_.Bind(&ptr_info, level_db_wrapper_ptr_.associated_group());
+    observer_binding_.Bind(&ptr_info, associated_group());
     level_db_wrapper_ptr_->AddObserver(std::move(ptr_info));
   }
 
   void set_mock_data(const std::string& key, const std::string& value) {
     mock_data_[StdStringToUint8Vector(key)] = StdStringToUint8Vector(value);
   }
 
   void set_mock_data(const std::vector<uint8_t>& key,
                      const std::vector<uint8_t>& value) {
     mock_data_[key] = value;
   }
 
   bool has_mock_data(const std::string& key) {
     return mock_data_.find(StdStringToUint8Vector(key)) != mock_data_.end();
   }
 
   std::string get_mock_data(const std::string& key) {
     return has_mock_data(key)
                ? Uint8VectorToStdString(mock_data_[StdStringToUint8Vector(key)])
                : "";
   }
 
   mojom::LevelDBWrapper* wrapper() { return level_db_wrapper_ptr_.get(); }
+  mojo::AssociatedGroup* associated_group() {
+    return level_db_wrapper_ptr_.associated_group();
+  }
 
   bool GetSync(const std::vector<uint8_t>& key, std::vector<uint8_t>* result) {
     base::RunLoop run_loop;
     bool success = false;
     wrapper()->Get(key, base::Bind(&GetCallback, run_loop.QuitClosure(),
                                    &success, result));
     run_loop.Run();
     return success;
   }
 
@@ skipping 54 matching lines @@
   }
   void KeyDeleted(const std::vector<uint8_t>& key,
                   const std::vector<uint8_t>& old_value,
                   const std::string& source) override {
     observations_.push_back({Observation::kDelete, Uint8VectorToStdString(key),
                              Uint8VectorToStdString(old_value), "", source});
   }
   void AllDeleted(const std::string& source) override {
     observations_.push_back({Observation::kDeleteAll, "", "", "", source});
   }
-  void GetAllComplete(const std::string& source) override {}
 
   TestBrowserThreadBundle thread_bundle_;
   std::map<std::vector<uint8_t>, std::vector<uint8_t>> mock_data_;
   MockLevelDBDatabase db_;
   LevelDBWrapperImpl level_db_wrapper_;
   mojom::LevelDBWrapperPtr level_db_wrapper_ptr_;
   mojo::AssociatedBinding<mojom::LevelDBObserver> observer_binding_;
   std::vector<Observation> observations_;
 };
 
@@ skipping 23 matching lines @@
   EXPECT_TRUE(PutSync(key, value));
 
   std::vector<uint8_t> result;
   EXPECT_TRUE(GetSync(key, &result));
   EXPECT_EQ(value, result);
 }
 
 TEST_F(LevelDBWrapperImplTest, GetAll) {
   leveldb::mojom::DatabaseError status;
   std::vector<mojom::KeyValuePtr> data;
-  EXPECT_TRUE(wrapper()->GetAll(kTestSource, &status, &data));
+  base::RunLoop run_loop;
+  bool result = false;
+  EXPECT_TRUE(wrapper()->GetAll(
+      GetAllCallback::CreateAndBind(associated_group(), &result,
+                                    run_loop.QuitClosure()),
+      &status, &data));
   EXPECT_EQ(leveldb::mojom::DatabaseError::OK, status);
   EXPECT_EQ(2u, data.size());
+  EXPECT_FALSE(result);
+  run_loop.Run();
+  EXPECT_TRUE(result);
 }
 
 TEST_F(LevelDBWrapperImplTest, CommitPutToDB) {
   std::string key1 = "123";
   std::string value1 = "foo";
   std::string key2 = "abc";
   std::string value2 = "data abc";
 
   EXPECT_TRUE(
       PutSync(StdStringToUint8Vector(key1), StdStringToUint8Vector(value1)));
@@ skipping 152 matching lines @@
   // Reducing size should also succeed.
   value.clear();
   EXPECT_TRUE(PutSync(key, value));
 
   // Increasing size should fail.
   value.resize(1, 'a');
   EXPECT_FALSE(PutSync(key, value));
 }
 
 }  // namespace content