DO NOT SUBMIT: Show silent service manager failure

services/service_manager/service_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 "services/service_manager/service_manager.h"
 
 #include <stdint.h>
 
 #include <utility>
 
@@ skipping 194 matching lines @@
       std::stringstream ss;
       ss << "Connection InterfaceProviderSpec prevented service: "
          << params->source().name() << " from binding interface: "
          << params->interface_name() << " exposed by: " << identity_.name();
       LOG(ERROR) << ss.str();
       params->bind_interface_callback().Run(mojom::ConnectResult::ACCESS_DENIED,
                                             identity_.user_id());
       return false;
     }
 
+    LOG(INFO) << "Call callback: " << identity().name();
     params->bind_interface_callback().Run(mojom::ConnectResult::SUCCEEDED,
                                           identity_.user_id());
 
     pending_service_connections_++;
+    LOG(INFO) << "iname: " << params->interface_name();
+    auto interface_pipe = params->TakeInterfaceRequestPipe();
+    LOG(INFO) << "ServiceManager::Instance::BindInterface: "
+              << interface_pipe.get().value();
     service_->OnBindInterface(
         ServiceInfo(params->source(), source_specs),
         params->interface_name(),
-        params->TakeInterfaceRequestPipe(),
+        std::move(interface_pipe),
         base::Bind(&Instance::OnConnectComplete, base::Unretained(this)));
     return true;
   }
 
   void OnConnectComplete() {
+    LOG(INFO) << "OnConnectComplete: " << identity().name();
     DCHECK_GT(pending_service_connections_, 0);
     pending_service_connections_--;
   }
 
   void StartWithService(mojom::ServicePtr service) {
+    LOG(INFO) << "ServiceManagerInstance::StartWithService: "
+              << identity().name();
     CHECK(!service_);
     state_ = State::STARTING;
     service_ = std::move(service);
     service_.set_connection_error_handler(
         base::Bind(&Instance::OnServiceLost, base::Unretained(this),
                    service_manager_->GetWeakPtr()));
     service_->OnStart(ServiceInfo(identity_, interface_provider_specs_),
                       base::Bind(&Instance::OnStartComplete,
                                  base::Unretained(this)));
   }
@@ skipping 98 matching lines @@
     params->set_target(target);
     params->set_remote_interfaces(std::move(remote_interfaces));
     params->set_connect_callback(callback);
     service_manager_->Connect(std::move(params), weak_factory_.GetWeakPtr());
   }
 
   void BindInterface(const service_manager::Identity& in_target,
                      const std::string& interface_name,
                      mojo::ScopedMessagePipeHandle interface_pipe,
                      const BindInterfaceCallback& callback) override {
+    LOG_IF(INFO, interface_name == "prefs::mojom::PrefStoreRegistry")
+        << "ServiceManager::Instance::BindInterface";
+    LOG(INFO) << "ServiceManager::BindInterface: "
+              << interface_pipe.get().value();
     Identity target = in_target;
     mojom::ConnectResult result =
         ValidateConnectParams(&target, nullptr, nullptr);
     if (!Succeeded(result)) {
       callback.Run(result, mojom::kInheritUserID);
       return;
     }
 
     std::unique_ptr<ConnectParams> params(new ConnectParams);
     params->set_source(identity_);
@@ skipping 131 matching lines @@
   void PIDAvailable(base::ProcessId pid) {
     if (pid == base::kNullProcessId) {
       service_manager_->OnInstanceError(this);
       return;
     }
     pid_ = pid;
   }
 
   void OnServiceLost(
       base::WeakPtr<service_manager::ServiceManager> service_manager) {
+    LOG(INFO) << "ServiceManagerInstance::OnServiceLost: " << identity().name();
     service_.reset();
     OnConnectionLost(service_manager);
   }
 
   void OnConnectionLost(
       base::WeakPtr<service_manager::ServiceManager> service_manager) {
     // Any time a Connector is lost or we lose the Service connection, it
     // may have been the last pipe using this Instance. If so, clean up.
     if (service_manager && !service_) {
       if (connectors_.empty())
@@ skipping 232 matching lines @@
 
   EraseInstanceIdentity(instance);
   auto it = instances_.find(instance);
   DCHECK(it != instances_.end());
 
   // Deletes |instance|.
   instances_.erase(it);
 }
 
 void ServiceManager::OnInstanceUnreachable(Instance* instance) {
+  LOG(INFO) << "ServiceManager::OnInstanceUnreachable: "
+            << instance->identity().name();
   // If an Instance becomes unreachable, new connection requests for this
   // identity will elicit a new Instance instantiation. The unreachable instance
   // remains alive.
   EraseInstanceIdentity(instance);
 }
 
 void ServiceManager::OnInstanceStopped(const Identity& identity) {
   listeners_.ForAllPtrs([identity](mojom::ServiceManagerListener* listener) {
     listener->OnServiceStopped(identity);
   });
   if (!instance_quit_callback_.is_null())
     instance_quit_callback_.Run(identity);
 }
 
 void ServiceManager::Connect(std::unique_ptr<ConnectParams> params,
                              base::WeakPtr<Instance> source_instance) {
+  LOG_IF(INFO, params->target().name() == "preferences")
+      << "ServiceManager::Connect";
   TRACE_EVENT_INSTANT1("service_manager", "ServiceManager::Connect",
                        TRACE_EVENT_SCOPE_THREAD, "original_name",
                        params->target().name());
   DCHECK(!params->target().name().empty());
   DCHECK(base::IsValidGUID(params->target().user_id()));
   DCHECK_NE(mojom::kInheritUserID, params->target().user_id());
   DCHECK(!params->HasClientProcessInfo() ||
          !identity_to_instance_.count(params->target()));
 
   // Connect to an existing matching instance, if possible.
@@ skipping 116 matching lines @@
   for (auto& instance : identity_to_instance_)
     instances.push_back(instance.second->CreateRunningServiceInfo());
   listener->OnInit(std::move(instances));
 
   listeners_.AddPtr(std::move(listener));
 }
 
 void ServiceManager::CreateServiceWithFactory(const Identity& service_factory,
                                               const std::string& name,
                                               mojom::ServiceRequest request) {
+  LOG_IF(INFO, name == "preferences")
+      << "ServiceManager::CreateServiceWithFactory";
   mojom::ServiceFactory* factory = GetServiceFactory(service_factory);
   factory->CreateService(std::move(request), name);
 }
 
 mojom::ServiceFactory* ServiceManager::GetServiceFactory(
     const Identity& service_factory_identity) {
   auto it = service_factories_.find(service_factory_identity);
   if (it != service_factories_.end())
     return it->second.get();
 
   Identity source_identity(service_manager::mojom::kServiceName,
                            mojom::kInheritUserID);
   mojom::ServiceFactoryPtr factory;
   BindInterface(this, source_identity, service_factory_identity, &factory);
   mojom::ServiceFactory* factory_interface = factory.get();
   factory.set_connection_error_handler(
       base::Bind(&service_manager::ServiceManager::OnServiceFactoryLost,
                  weak_ptr_factory_.GetWeakPtr(), service_factory_identity));
   service_factories_[service_factory_identity] = std::move(factory);
   return factory_interface;
 }
 
 void ServiceManager::OnServiceFactoryLost(const Identity& which) {
+  LOG(INFO) << "ServiceManager::OnServiceFactoryLost";
   // Remove the mapping.
   auto it = service_factories_.find(which);
   DCHECK(it != service_factories_.end());
   service_factories_.erase(it);
 }
 
 void ServiceManager::OnGotResolvedName(std::unique_ptr<ConnectParams> params,
                                        bool has_source_instance,
                                        base::WeakPtr<Instance> source_instance,
                                        mojom::ResolveResultPtr result,
                                        mojom::ResolveResultPtr parent) {
+  LOG_IF(INFO, params->target().name() == "preferences")
+      << "ServiceManager::OnGotResolvedName";
   // If this request was originated by a specific Instance and that Instance is
   // no longer around, we ignore this response.
   if (has_source_instance && !source_instance)
     return;
 
   // If name resolution failed, we drop the connection.
   if (!result) {
     LOG(ERROR) << "Failed to resolve service name: " << params->target().name();
     RunCallback(params.get(), mojom::ConnectResult::INVALID_ARGUMENT, "");
     return;
@@ skipping 59 matching lines @@
     // TODO(beng): There may be some cases where it's valid to have an empty
     // spec, so we should probably include a return value in |result|.
     if (result->interface_provider_specs.empty()) {
       LOG(ERROR)
           << "Error: The catalog was unable to read a manifest for service \""
           << result->name << "\".";
       RunCallback(params.get(), mojom::ConnectResult::ACCESS_DENIED, "");
       return;
     }
 
+    LOG_IF(INFO, params->target().name() == "preferences")
+        << "parent: " << bool(parent);
     if (parent) {
       // This service is provided by another service via a ServiceFactory.
       std::string target_user_id = target.user_id();
       std::string factory_instance_name = instance_name;
 
       auto spec_iter = parent->interface_provider_specs.find(
           mojom::kServiceManager_ConnectorSpec);
       if (spec_iter != parent->interface_provider_specs.end() &&
               HasCapability(spec_iter->second, kCapability_InstancePerChild)) {
         // If configured to start a new instance, create a random instance name
@@ skipping 34 matching lines @@
     bool connected = instance->CallOnConnect(&params);
     DCHECK(connected);
   }
 }
 
 base::WeakPtr<ServiceManager> ServiceManager::GetWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 }  // namespace service_manager