Make CapabilityFilter non-nullable.

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)) {}
+    : ConnectParams(URLRequest::From(url)) {}
 ApplicationImpl::ConnectParams::ConnectParams(URLRequestPtr request)
-    : request_(request.Pass()) {}
+    : request_(request.Pass()), filter_(CapabilityFilter::New()) {
+  filter_->filter.mark_non_null();
+}
 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) {
   ConnectParams params(url);
+  params.set_filter(CreatePermissiveCapabilityFilter());
   return ConnectToApplication(&params);
 }
 
 scoped_ptr<ApplicationConnection>
     ApplicationImpl::ConnectToApplication(ConnectParams* params) {
   if (!shell_)
     return nullptr;
   DCHECK(params);
   URLRequestPtr request = params->TakeRequest();
   ServiceProviderPtr local_services;
@@ skipping 92 matching lines @@
   termination_closure_.Run();
 }
 
 void ApplicationImpl::UnbindConnections(
     InterfaceRequest<Application>* application_request,
     ShellPtr* shell) {
   *application_request = binding_.Unbind();
   shell->Bind(shell_.PassInterface());
 }
 
+CapabilityFilterPtr CreatePermissiveCapabilityFilter() {
+  CapabilityFilterPtr filter(CapabilityFilter::New());
+  Array<String> all_interfaces;
+  all_interfaces.push_back("*");
+  filter->filter.insert("*", all_interfaces.Pass());
+  return filter.Pass();
+}
+
 }  // namespace mojo