Mojo C++ bindings: remove usage of AssociatedGroup from content/

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/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "components/leveldb/public/cpp/util.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/test/mock_leveldb_database.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";
 const char* kTestSource = "source";
 const size_t kTestSizeLimit = 512;
 
 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);
+    auto request = mojo::MakeRequest(&ptr_info);
     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 {
@@ skipping 55 matching lines @@
                           10 * 1024 * 1024 /* max_bytes_per_hour */,
                           60 /* max_commits_per_hour */,
                           &delegate_),
         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, associated_group());
+    observer_binding_.Bind(&ptr_info);
     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)])
                : "";
   }
 
   void clear_mock_data() { mock_data_.clear(); }
 
   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 98 matching lines @@
   EXPECT_TRUE(GetSync(key, &result));
   EXPECT_EQ(value, result);
 }
 
 TEST_F(LevelDBWrapperImplTest, GetAll) {
   leveldb::mojom::DatabaseError status;
   std::vector<mojom::KeyValuePtr> data;
   base::RunLoop run_loop;
   bool result = false;
   EXPECT_TRUE(wrapper()->GetAll(
-      GetAllCallback::CreateAndBind(associated_group(), &result,
-                                    run_loop.QuitClosure()),
-      &status, &data));
+      GetAllCallback::CreateAndBind(&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";
@@ skipping 209 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