Allow Catalogs to be constructed per-user

mojo/shell/tests/loader_unittest.cc

 // 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 <utility>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
-#include "mojo/services/catalog/owner.h"
+#include "mojo/services/catalog/factory.h"
 #include "mojo/services/catalog/store.h"
 #include "mojo/shell/connect_util.h"
 #include "mojo/shell/loader.h"
 #include "mojo/shell/public/cpp/connector.h"
 #include "mojo/shell/public/cpp/interface_factory.h"
 #include "mojo/shell/public/cpp/shell_client.h"
 #include "mojo/shell/public/cpp/shell_connection.h"
 #include "mojo/shell/public/interfaces/interface_provider.mojom.h"
 #include "mojo/shell/shell.h"
 #include "mojo/shell/tests/test.mojom.h"
@@ skipping 370 matching lines @@
   loop->Quit();
 }
 
 class LoaderTest : public testing::Test {
  public:
   LoaderTest() : tester_context_(&loop_) {}
   ~LoaderTest() override {}
 
   void SetUp() override {
     blocking_pool_ = new base::SequencedWorkerPool(3, "blocking_pool");
-    catalog_.reset(new catalog::Owner(blocking_pool_.get(), nullptr));
+    catalog_.reset(new catalog::Factory(blocking_pool_.get(), nullptr));
     shell_.reset(new Shell(nullptr, catalog_->TakeShellClient()));
     test_loader_ = new TestLoader(&context_);
     shell_->set_default_loader(scoped_ptr<Loader>(test_loader_));
 
     TestServicePtr service_proxy;
     ConnectToInterface(kTestURLString, &service_proxy);
     test_client_.reset(new TestClient(std::move(service_proxy)));
   }
 
   void TearDown() override {
@@ skipping 30 matching lines @@
 
     mojo::GetInterface(remote_interfaces.get(), ptr);
   }
 
   base::ShadowingAtExitManager at_exit_;
   TestLoader* test_loader_;
   TesterContext tester_context_;
   TestContext context_;
   base::MessageLoop loop_;
   scoped_ptr<TestClient> test_client_;
-  scoped_ptr<catalog::Owner> catalog_;
+  scoped_ptr<catalog::Factory> catalog_;
   scoped_refptr<base::SequencedWorkerPool> blocking_pool_;
   scoped_ptr<Shell> shell_;
   DISALLOW_COPY_AND_ASSIGN(LoaderTest);
 };
 
 TEST_F(LoaderTest, Basic) {
   test_client_->Test("test");
   loop_.Run();
   EXPECT_EQ(std::string("test"), context_.last_test_string);
 }
 
 TEST_F(LoaderTest, ClientError) {
   test_client_->Test("test");
   EXPECT_TRUE(HasRunningInstanceForName(kTestURLString));
   loop_.Run();
   EXPECT_EQ(1, context_.num_impls);
   test_client_.reset();
   loop_.Run();
   EXPECT_EQ(0, context_.num_impls);
   EXPECT_TRUE(HasRunningInstanceForName(kTestURLString));
 }
 
 TEST_F(LoaderTest, Deletes) {
   {
-    catalog::Owner catalog(blocking_pool_.get(), nullptr);
+    catalog::Factory catalog(blocking_pool_.get(), nullptr);
     Shell shell(nullptr, catalog.TakeShellClient());
     TestLoader* default_loader = new TestLoader(&context_);
     TestLoader* name_loader1 = new TestLoader(&context_);
     TestLoader* name_loader2 = new TestLoader(&context_);
     shell.set_default_loader(scoped_ptr<Loader>(default_loader));
     shell.SetLoaderForName(scoped_ptr<Loader>(name_loader1), "test:test1");
     shell.SetLoaderForName(scoped_ptr<Loader>(name_loader2), "test:test1");
   }
   EXPECT_EQ(3, context_.num_loader_deletes);
 }
@@ skipping 59 matching lines @@
   EXPECT_EQ(2, test_loader_->num_loads());
 
   // A different identity because the domain is different.
   ConnectToInterface("test:bar", &test_service);
   EXPECT_EQ(3, test_loader_->num_loads());
 }
 
 }  // namespace test
 }  // namespace shell
 }  // namespace mojo