Revert of Make CapabilityFilter be part of Identity

mojo/shell/application_manager_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 "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"
@@ skipping 669 matching lines @@
   EXPECT_TRUE(c.encountered_error());
 }
 
 TEST_F(ApplicationManagerTest, TestEndApplicationClosure) {
   ClosingApplicationLoader* loader = new ClosingApplicationLoader();
   application_manager_->SetLoaderForURL(
       scoped_ptr<ApplicationLoader>(loader), GURL("test:test"));
 
   bool called = false;
   scoped_ptr<ConnectToApplicationParams> params(new ConnectToApplicationParams);
-  params->SetTargetURL(GURL("test:test"));
+  params->SetURLInfo(GURL("test:test"));
+  params->set_filter(GetPermissiveCapabilityFilter());
   params->set_on_application_end(
       base::Bind(&QuitClosure, base::Unretained(&called)));
   application_manager_->ConnectToApplication(params.Pass());
   loop_.Run();
   EXPECT_TRUE(called);
 }
 
 TEST(ApplicationManagerTest2, ContentHandlerConnectionGetsRequestorURL) {
   const GURL content_handler_url("http://test.content.handler");
   const GURL requestor_url("http://requestor.url");
   TestContext test_context;
   base::MessageLoop loop;
   scoped_ptr<AMTestPackageManager> test_package_manager(
       new AMTestPackageManager);
   test_package_manager->set_create_test_fetcher(true);
   test_package_manager->RegisterContentHandler(kTestMimeType,
                                                content_handler_url);
   ApplicationManager application_manager(test_package_manager.Pass());
   application_manager.set_default_loader(nullptr);
 
   TestApplicationLoader* loader = new TestApplicationLoader;
   loader->set_context(&test_context);
   application_manager.SetLoaderForURL(scoped_ptr<ApplicationLoader>(loader),
                                       content_handler_url);
 
   bool called = false;
   scoped_ptr<ConnectToApplicationParams> params(new ConnectToApplicationParams);
-  params->set_source(Identity(requestor_url));
-  params->SetTargetURL(GURL("test:test"));
+  params->set_originator_identity(Identity(requestor_url));
+  params->set_originator_filter(GetPermissiveCapabilityFilter());
+  params->SetURLInfo(GURL("test:test"));
+  params->set_filter(GetPermissiveCapabilityFilter());
   params->set_on_application_end(
       base::Bind(&QuitClosure, base::Unretained(&called)));
   application_manager.ConnectToApplication(params.Pass());
   loop.Run();
   EXPECT_TRUE(called);
 
   ASSERT_EQ(1, loader->num_loads());
   EXPECT_EQ(requestor_url, loader->last_requestor_url());
 }
 
@@ skipping 48 matching lines @@
   content_handler_loader->set_context(&test_context);
   application_manager.SetLoaderForURL(
       scoped_ptr<ApplicationLoader>(content_handler_loader),
       content_handler_url);
 
   uint32_t content_handler_id;
   {
     base::RunLoop run_loop;
     scoped_ptr<ConnectToApplicationParams> params(
         new ConnectToApplicationParams);
-    params->set_source(Identity(requestor_url));
-    params->SetTargetURL(GURL("test:test"));
+    params->set_originator_identity(Identity(requestor_url));
+    params->set_originator_filter(GetPermissiveCapabilityFilter());
+    params->SetURLInfo(GURL("test:test"));
+    params->set_filter(GetPermissiveCapabilityFilter());
     params->set_connect_callback([&content_handler_id, &run_loop](uint32_t t) {
       content_handler_id = t;
       run_loop.Quit();
     });
     application_manager.ConnectToApplication(params.Pass());
     run_loop.Run();
     EXPECT_NE(Shell::kInvalidContentHandlerID, content_handler_id);
   }
 
   uint32_t content_handler_id2;
   {
     base::RunLoop run_loop;
     scoped_ptr<ConnectToApplicationParams> params(
         new ConnectToApplicationParams);
-    params->set_source(Identity(requestor_url));
-    params->SetTargetURL(GURL("test:test"));
+    params->set_originator_identity(Identity(requestor_url));
+    params->set_originator_filter(GetPermissiveCapabilityFilter());
+    params->SetURLInfo(GURL("test:test"));
+    params->set_filter(GetPermissiveCapabilityFilter());
     params->set_connect_callback([&content_handler_id2, &run_loop](uint32_t t) {
       content_handler_id2 = t;
       run_loop.Quit();
     });
     application_manager.ConnectToApplication(params.Pass());
     run_loop.Run();
     EXPECT_NE(Shell::kInvalidContentHandlerID, content_handler_id2);
   }
   EXPECT_EQ(content_handler_id, content_handler_id2);
 }
@@ skipping 16 matching lines @@
   content_handler_loader->set_context(&test_context);
   application_manager.SetLoaderForURL(
       scoped_ptr<ApplicationLoader>(content_handler_loader),
       content_handler_url);
 
   uint32_t content_handler_id;
   {
     base::RunLoop run_loop;
     scoped_ptr<ConnectToApplicationParams> params(
         new ConnectToApplicationParams);
-    params->set_source(Identity(requestor_url));
-    params->SetTargetURL(GURL("test:test"));
+    params->set_originator_identity(Identity(requestor_url));
+    params->set_originator_filter(GetPermissiveCapabilityFilter());
+    params->SetURLInfo(GURL("test:test"));
+    params->set_filter(GetPermissiveCapabilityFilter());
     params->set_connect_callback([&content_handler_id, &run_loop](uint32_t t) {
       content_handler_id = t;
       run_loop.Quit();
     });
     application_manager.ConnectToApplication(params.Pass());
     run_loop.Run();
     EXPECT_NE(Shell::kInvalidContentHandlerID, content_handler_id);
   }
 
   const std::string mime_type2("test/mime-type2");
   const GURL content_handler_url2("http://test.content2.handler");
   test_package_manager->set_fetcher_url(GURL("test2:test2"));
   test_package_manager->set_mime_type(mime_type2);
   test_package_manager->RegisterContentHandler(mime_type2,
                                                content_handler_url2);
 
   TestApplicationLoader* content_handler_loader2 = new TestApplicationLoader;
   content_handler_loader->set_create_content_handler(true);
   content_handler_loader->set_context(&test_context);
   application_manager.SetLoaderForURL(
       scoped_ptr<ApplicationLoader>(content_handler_loader2),
       content_handler_url2);
 
   uint32_t content_handler_id2;
   {
     base::RunLoop run_loop;
     scoped_ptr<ConnectToApplicationParams> params(
         new ConnectToApplicationParams);
-    params->set_source(Identity(requestor_url));
-    params->SetTargetURL(GURL("test2:test2"));
+    params->set_originator_identity(Identity(requestor_url));
+    params->set_originator_filter(GetPermissiveCapabilityFilter());
+    params->SetURLInfo(GURL("test2:test2"));
+    params->set_filter(GetPermissiveCapabilityFilter());
     params->set_connect_callback([&content_handler_id2, &run_loop](uint32_t t) {
       content_handler_id2 = t;
       run_loop.Quit();
     });
     application_manager.ConnectToApplication(params.Pass());
     run_loop.Run();
     EXPECT_NE(Shell::kInvalidContentHandlerID, content_handler_id2);
   }
   EXPECT_NE(content_handler_id, content_handler_id2);
 }
 
 TEST_F(ApplicationManagerTest,
        ConnectWithNoContentHandlerGetsInvalidContentHandlerId) {
   application_manager_->SetLoaderForURL(
       scoped_ptr<ApplicationLoader>(new TestApplicationLoader),
       GURL("test:test"));
 
   uint32_t content_handler_id = 1u;
   scoped_ptr<ConnectToApplicationParams> params(new ConnectToApplicationParams);
-  params->SetTargetURL(GURL("test:test"));
+  params->SetURLInfo(GURL("test:test"));
+  params->set_filter(GetPermissiveCapabilityFilter());
   params->set_connect_callback(
       [&content_handler_id](uint32_t t) { content_handler_id = t; });
   application_manager_->ConnectToApplication(params.Pass());
   EXPECT_EQ(0u, content_handler_id);
 }
 
 }  // namespace
 }  // namespace shell
 }  // namespace mojo