Make CapabilityFilter be part of Identity

mojo/shell/application_manager.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 "mojo/shell/application_manager.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/macros.h"
@@ skipping 57 matching lines @@
 }
 
 void ApplicationManager::TerminateShellConnections() {
   STLDeleteValues(&identity_to_instance_);
 }
 
 void ApplicationManager::ConnectToApplication(
     scoped_ptr<ConnectToApplicationParams> params) {
   TRACE_EVENT_INSTANT1("mojo_shell", "ApplicationManager::ConnectToApplication",
                        TRACE_EVENT_SCOPE_THREAD, "original_url",
-                       params->app_url().spec());
-  DCHECK(params->app_url().is_valid());
+                       params->target().url().spec());
+  DCHECK(params->target().url().is_valid());
 
   // Connect to an existing matching instance, if possible.
   if (ConnectToRunningApplication(&params))
     return;
 
-  ApplicationLoader* loader = GetLoaderForURL(params->app_url());
+  ApplicationLoader* loader = GetLoaderForURL(params->target().url());
   if (loader) {
-    GURL url = params->app_url();
+    GURL url = params->target().url();
     loader->Load(url, CreateInstance(params.Pass(), nullptr));
     return;
   }
 
-  URLRequestPtr original_url_request = params->TakeAppURLRequest();
+  URLRequestPtr original_url_request = params->TakeTargetURLRequest();
   auto callback =
       base::Bind(&ApplicationManager::HandleFetchCallback,
                  weak_ptr_factory_.GetWeakPtr(), base::Passed(&params));
   package_manager_->FetchRequest(original_url_request.Pass(), callback);
 }
 
 bool ApplicationManager::ConnectToRunningApplication(
     scoped_ptr<ConnectToApplicationParams>* params) {
-  ApplicationInstance* instance = GetApplicationInstance(
-      Identity((*params)->app_url(), (*params)->qualifier()));
+  ApplicationInstance* instance = GetApplicationInstance((*params)->target());
   if (!instance)
     return false;
 
   instance->ConnectToClient(params->Pass());
   return true;
 }
 
 InterfaceRequest<Application> ApplicationManager::CreateInstance(
     scoped_ptr<ConnectToApplicationParams> params,
     ApplicationInstance** resulting_instance) {
-  Identity app_identity(params->app_url(), params->qualifier());
-
+  Identity target_id = params->target();
   ApplicationPtr application;
   InterfaceRequest<Application> application_request = GetProxy(&application);
   ApplicationInstance* instance = new ApplicationInstance(
-      application.Pass(), this, params->originator_identity(), app_identity,
-      params->filter(), Shell::kInvalidContentHandlerID,
+      application.Pass(), this, target_id, Shell::kInvalidContentHandlerID,
       params->on_application_end());
-  DCHECK(identity_to_instance_.find(app_identity) ==
+  DCHECK(identity_to_instance_.find(target_id) ==
          identity_to_instance_.end());
-  identity_to_instance_[app_identity] = instance;
+  identity_to_instance_[target_id] = instance;
   instance->InitializeApplication();
   instance->ConnectToClient(params.Pass());
   if (resulting_instance)
     *resulting_instance = instance;
   return application_request.Pass();
 }
 
 ApplicationInstance* ApplicationManager::GetApplicationInstance(
     const Identity& identity) const {
   const auto& it = identity_to_instance_.find(identity);
@@ skipping 12 matching lines @@
   GURL redirect_url = fetcher->GetRedirectURL();
   if (!redirect_url.is_empty()) {
     // And around we go again... Whee!
     // TODO(sky): this loses the original URL info.
     URLRequestPtr new_request = URLRequest::New();
     new_request->url = redirect_url.spec();
     HttpHeaderPtr header = HttpHeader::New();
     header->name = "Referer";
     header->value = fetcher->GetRedirectReferer().spec();
     new_request->headers.push_back(header.Pass());
-    params->SetURLInfo(new_request.Pass());
+    params->SetTargetURLRequest(new_request.Pass());
     ConnectToApplication(params.Pass());
     return;
   }
 
   // We already checked if the application was running before we fetched it, but
   // it might have started while the fetch was outstanding. We don't want to
   // have two copies of the app running, so check again.
   if (ConnectToRunningApplication(&params))
     return;
 
-  Identity originator_identity = params->originator_identity();
-  CapabilityFilter originator_filter = params->originator_filter();
-  CapabilityFilter filter = params->filter();
-  GURL app_url = params->app_url();
-  std::string qualifier = params->qualifier();
+  Identity source = params->source();
+  Identity target = params->target();
   Shell::ConnectToApplicationCallback connect_callback =
       params->connect_callback();
   params->set_connect_callback(EmptyConnectCallback());
   ApplicationInstance* app = nullptr;
   InterfaceRequest<Application> request(CreateInstance(params.Pass(), &app));
 
 
   GURL content_handler_url;
   URLResponsePtr new_response;
+  std::string qualifier;
   if (package_manager_->HandleWithContentHandler(fetcher.get(),
-                                                 app_url,
+                                                 target.url(),
                                                  blocking_pool_,
                                                  &new_response,
                                                  &content_handler_url,
                                                  &qualifier)) {
-    LoadWithContentHandler(originator_identity, originator_filter,
-                           content_handler_url, qualifier, filter,
-                           connect_callback, app, request.Pass(),
-                           new_response.Pass());
+    Identity content_handler(content_handler_url, qualifier, target.filter());
+    LoadWithContentHandler(source, content_handler, connect_callback, app,
+                           request.Pass(), new_response.Pass());
   } else {
     // TODO(erg): Have a better way of switching the sandbox on. For now, switch
     // it on hard coded when we're using some of the sandboxable core services.
     bool start_sandboxed = false;
     if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kMojoNoSandbox)) {
-      if (app_url == GURL("mojo://core_services/") && qualifier == "Core")
-        start_sandboxed = true;
-      else if (app_url == GURL("mojo://html_viewer/"))
-        start_sandboxed = true;
+      start_sandboxed = (target.url() == GURL("mojo://core_services/") &&
+                            target.qualifier() == "Core") ||
+                        target.url() == GURL("mojo://html_viewer/");
     }
 
     connect_callback.Run(Shell::kInvalidContentHandlerID);
 
     fetcher->AsPath(blocking_pool_,
                     base::Bind(&ApplicationManager::RunNativeApplication,
                                weak_ptr_factory_.GetWeakPtr(),
                                base::Passed(request.Pass()), start_sandboxed,
                                base::Passed(fetcher.Pass())));
   }
@@ skipping 19 matching lines @@
   TRACE_EVENT1("mojo_shell", "ApplicationManager::RunNativeApplication", "path",
                path.AsUTF8Unsafe());
   NativeRunner* runner = native_runner_factory_->Create().release();
   native_runners_.push_back(runner);
   runner->Start(path, start_sandboxed, application_request.Pass(),
                 base::Bind(&ApplicationManager::CleanupRunner,
                            weak_ptr_factory_.GetWeakPtr(), runner));
 }
 
 void ApplicationManager::LoadWithContentHandler(
-    const Identity& originator_identity,
-    const CapabilityFilter& originator_filter,
-    const GURL& content_handler_url,
-    const std::string& qualifier,
-    const CapabilityFilter& filter,
+    const Identity& source,
+    const Identity& content_handler,
     const Shell::ConnectToApplicationCallback& connect_callback,
     ApplicationInstance* app,
     InterfaceRequest<Application> application_request,
     URLResponsePtr url_response) {
   ContentHandlerConnection* connection = nullptr;
-  Identity content_handler_identity(content_handler_url, qualifier);
   // TODO(beng): Figure out the extent to which capability filter should be
   //             factored into handler identity.
   IdentityToContentHandlerMap::iterator iter =
-      identity_to_content_handler_.find(content_handler_identity);
+      identity_to_content_handler_.find(content_handler);
   if (iter != identity_to_content_handler_.end()) {
     connection = iter->second;
   } else {
     connection = new ContentHandlerConnection(
-        this, originator_identity, originator_filter, content_handler_url,
-        qualifier, filter, ++content_handler_id_counter_);
-    identity_to_content_handler_[content_handler_identity] = connection;
+        this, source, content_handler, ++content_handler_id_counter_);
+    identity_to_content_handler_[content_handler] = connection;
   }
 
   app->set_requesting_content_handler_id(connection->id());
   connection->content_handler()->StartApplication(application_request.Pass(),
                                                   url_response.Pass());
   connect_callback.Run(connection->id());
 }
 
 void ApplicationManager::SetLoaderForURL(scoped_ptr<ApplicationLoader> loader,
                                          const GURL& url) {
@@ skipping 20 matching lines @@
   DCHECK(it != identity_to_instance_.end());
   delete it->second;
   identity_to_instance_.erase(it);
   if (!on_application_end.is_null())
     on_application_end.Run();
 }
 
 void ApplicationManager::OnContentHandlerConnectionClosed(
     ContentHandlerConnection* content_handler) {
   // Remove the mapping to the content handler.
-  auto it = identity_to_content_handler_.find(
-      Identity(content_handler->content_handler_url(),
-               content_handler->content_handler_qualifier()));
+  auto it = identity_to_content_handler_.find(content_handler->identity());
   DCHECK(it != identity_to_content_handler_.end());
   identity_to_content_handler_.erase(it);
 }
 
 void ApplicationManager::CleanupRunner(NativeRunner* runner) {
   native_runners_.erase(
       std::find(native_runners_.begin(), native_runners_.end(), runner));
 }
 
 Shell::ConnectToApplicationCallback EmptyConnectCallback() {
   return base::Bind(&OnEmptyOnConnectCallback);
 }
 
 }  // namespace shell
 }  // namespace mojo