Mojo Spy core first cut

mojo/service_manager/service_manager.cc

 // Copyright 2013 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 <stdio.h>
 
 #include "mojo/service_manager/service_manager.h"
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
@@ skipping 52 matching lines @@
 // static
 bool ServiceManager::TestAPI::HasCreatedInstance() {
   return has_created_instance;
 }
 
 bool ServiceManager::TestAPI::HasFactoryForURL(const GURL& url) const {
   return manager_->url_to_service_factory_.find(url) !=
       manager_->url_to_service_factory_.end();
 }
 
-ServiceManager::ServiceManager() : default_loader_(NULL) {
+ServiceManager::ServiceManager()
+    : default_loader_(NULL),
+      interceptor_(NULL) {
 }
 
 ServiceManager::~ServiceManager() {
   for (URLToServiceFactoryMap::iterator it = url_to_service_factory_.begin();
        it != url_to_service_factory_.end(); ++it) {
     delete it->second;
   }
   url_to_service_factory_.clear();
 }
 
 // static
 ServiceManager* ServiceManager::GetInstance() {
   static base::LazyInstance<ServiceManager> instance =
       LAZY_INSTANCE_INITIALIZER;
   has_created_instance = true;
   return &instance.Get();
 }
 
 void ServiceManager::Connect(const GURL& url,
                              ScopedMessagePipeHandle client_handle) {
   URLToServiceFactoryMap::const_iterator service_it =
       url_to_service_factory_.find(url);
   ServiceFactory* service_factory;
   if (service_it != url_to_service_factory_.end()) {
     service_factory = service_it->second;
   } else {
     service_factory = new ServiceFactory(this, url);
     url_to_service_factory_[url] = service_factory;
   }
-  service_factory->ConnectToClient(client_handle.Pass());
+  if (interceptor_)

[DaveMoore, 2014/04/04 21:06:46]

Please include braces even if it's one statement on multiple lines.

[cpu_(ooo_6.6-7.5), 2014/04/04 23:42:45]

Done.

+    service_factory->ConnectToClient(
+        interceptor_->OnConnectToClient(url, client_handle.Pass()));
+  else
+    service_factory->ConnectToClient(client_handle.Pass());
 }
 
 void ServiceManager::SetLoaderForURL(ServiceLoader* loader, const GURL& url) {
   DCHECK(url_to_loader_.find(url) == url_to_loader_.end());
   url_to_loader_[url] = loader;
 }
 
 void ServiceManager::SetLoaderForScheme(ServiceLoader* loader,
                                         const std::string& scheme) {
   DCHECK(scheme_to_loader_.find(scheme) == scheme_to_loader_.end());
   scheme_to_loader_[scheme] = loader;
 }
 
+void ServiceManager::SetInterceptor(ServiceInterceptor* interceptor) {
+  interceptor_ = interceptor;
+}
+
 ServiceLoader* ServiceManager::GetLoaderForURL(const GURL& url) {
   URLToLoaderMap::const_iterator url_it = url_to_loader_.find(url);
   if (url_it != url_to_loader_.end())
     return url_it->second;
   SchemeToLoaderMap::const_iterator scheme_it =
       scheme_to_loader_.find(url.scheme());
   if (scheme_it != scheme_to_loader_.end())
     return scheme_it->second;
   DCHECK(default_loader_);
   return default_loader_;
 }
 
 void ServiceManager::OnServiceFactoryError(ServiceFactory* service_factory) {
   const GURL url = service_factory->url();
   URLToServiceFactoryMap::iterator it = url_to_service_factory_.find(url);
   DCHECK(it != url_to_service_factory_.end());
   delete it->second;
   url_to_service_factory_.erase(it);
   GetLoaderForURL(url)->OnServiceError(this, url);
 }
 
 }  // namespace mojo