Convert ConnectToApplication to take a params class

mojo/application/public/cpp/lib/application_impl.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/application/public/cpp/application_impl.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "mojo/application/public/cpp/application_delegate.h"
 #include "mojo/application/public/cpp/lib/service_registry.h"
+#include "mojo/converters/network/network_type_converters.h"
 #include "mojo/public/cpp/bindings/interface_ptr.h"
 #include "mojo/public/cpp/environment/logging.h"
 
 namespace mojo {
 
 namespace {
 
 void DefaultTerminationClosure() {
   if (base::MessageLoop::current() &&
       base::MessageLoop::current()->is_running())
     base::MessageLoop::current()->QuitWhenIdle();
 }
 
 }  // namespace
 
+ApplicationImpl::ConnectParams::ConnectParams(const std::string& url)
+  : request_(URLRequest::From(url)) {}
+ApplicationImpl::ConnectParams::ConnectParams(URLRequestPtr request)
+    : request_(request.Pass()) {}
+ApplicationImpl::ConnectParams::~ConnectParams() {}
+
 ApplicationImpl::ApplicationImpl(ApplicationDelegate* delegate,
                                  InterfaceRequest<Application> request)
     : ApplicationImpl(delegate, request.Pass(),
                       base::Bind(&DefaultTerminationClosure)) {
 }
 
 ApplicationImpl::ApplicationImpl(ApplicationDelegate* delegate,
                                  InterfaceRequest<Application> request,
                                  const Closure& termination_closure)
     : delegate_(delegate),
       binding_(this, request.Pass()),
       termination_closure_(termination_closure),
       app_lifetime_helper_(this),
       quit_requested_(false),
       weak_factory_(this) {}
 
 ApplicationImpl::~ApplicationImpl() {
   app_lifetime_helper_.OnQuit();
 }
 
 scoped_ptr<ApplicationConnection> ApplicationImpl::ConnectToApplication(
     const std::string& url) {
-  mojo::URLRequestPtr request(mojo::URLRequest::New());
-  request->url = url;
-  return ConnectToApplication(request.Pass());
-}
-
-scoped_ptr<ApplicationConnection> ApplicationImpl::ConnectToApplication(
-    URLRequestPtr request) {
-  return ConnectToApplicationWithCapabilityFilter(request.Pass(), nullptr);
+  ConnectParams params(url);
+  return ConnectToApplication(&params);
 }
 
 scoped_ptr<ApplicationConnection>
-    ApplicationImpl::ConnectToApplicationWithCapabilityFilter(
-        URLRequestPtr request,
-        CapabilityFilterPtr filter) {
+    ApplicationImpl::ConnectToApplication(ConnectParams* params) {
   if (!shell_)
     return nullptr;
+  DCHECK(params);
+  URLRequestPtr request = params->TakeRequest();
   ServiceProviderPtr local_services;
   InterfaceRequest<ServiceProvider> local_request = GetProxy(&local_services);
   ServiceProviderPtr remote_services;
   std::string application_url = request->url.To<std::string>();
   // We allow all interfaces on outgoing connections since we are presumably in
   // a position to know who we're talking to.
   // TODO(beng): is this a valid assumption or do we need to figure some way to
   //             filter here too?
   std::set<std::string> allowed;
   allowed.insert("*");
   InterfaceRequest<ServiceProvider> remote_services_proxy =
       GetProxy(&remote_services);
   scoped_ptr<internal::ServiceRegistry> registry(new internal::ServiceRegistry(
       application_url, application_url, remote_services.Pass(),
       local_request.Pass(), allowed));
   shell_->ConnectToApplication(request.Pass(), remote_services_proxy.Pass(),
-                               local_services.Pass(), filter.Pass(),
+                               local_services.Pass(),
+                               params->TakeFilter().Pass(),
                                registry->GetConnectToApplicationCallback());
   if (!delegate_->ConfigureOutgoingConnection(registry.get()))
     return nullptr;
   return registry.Pass();
 }
 
 void ApplicationImpl::WaitForInitialize() {
   DCHECK(!shell_.is_bound());
   binding_.WaitForIncomingMethodCall();
 }
@@ skipping 66 matching lines @@
 }
 
 void ApplicationImpl::UnbindConnections(
     InterfaceRequest<Application>* application_request,
     ShellPtr* shell) {
   *application_request = binding_.Unbind();
   shell->Bind(shell_.PassInterface());
 }
 
 }  // namespace mojo