Enable the mojo-based serial API in the renderer behind a flag.

extensions/browser/service_registration_manager.h

 // 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.
 
 #ifndef EXTENSIONS_BROWSER_SERVICE_REGISTRATION_MANAGER_H_
 #define EXTENSIONS_BROWSER_SERVICE_REGISTRATION_MANAGER_H_
 
+#include <map>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/memory/linked_ptr.h"
 #include "content/public/common/service_registry.h"
 #include "mojo/public/cpp/bindings/interface_request.h"
 
 namespace content {
 class RenderFrameHost;
 }
 
 namespace extensions {
 namespace internal {
 
 class ServiceFactoryBase {
  public:
   virtual ~ServiceFactoryBase() {}
 
   // Add this service factory to |service_registry|.
   virtual void Register(content::ServiceRegistry* service_registry) const = 0;
+
+  virtual std::string GetName() const = 0;
 };
 
 template <typename Interface>
 class ServiceFactory : public ServiceFactoryBase {
  public:
   explicit ServiceFactory(
       const base::Callback<void(mojo::InterfaceRequest<Interface>)>& factory)
       : factory_(factory) {}
   virtual ~ServiceFactory() {}
 
   virtual void Register(
       content::ServiceRegistry* service_registry) const override {
     service_registry->AddService(factory_);
   }
 
+  virtual std::string GetName() const override { return Interface::Name_; }
+
  private:
   const base::Callback<void(mojo::InterfaceRequest<Interface>)> factory_;
   DISALLOW_COPY_AND_ASSIGN(ServiceFactory);
 };
 
 }  // namespace internal
 
 // A meta service registry. This allows registration of service factories and
 // their associated extensions API permission name. Whenever a RenderFrameHost
 // is created, each service that the render frame should have access to (based
@@ skipping 15 matching lines @@
   template <typename Interface>
   void AddServiceFactory(
       const std::string& permission_name,
       const base::Callback<void(mojo::InterfaceRequest<Interface>)>& factory) {
     factories_.push_back(
         std::make_pair(permission_name,
                        linked_ptr<internal::ServiceFactoryBase>(
                            new internal::ServiceFactory<Interface>(factory))));
   }
 
+  // Overrides an existing service factory with |factory| for testing. This
+  // does not alter the permission checks used to determine whether a service
+  // is available.
+  template <typename Interface>
+  void OverrideServiceFactoryForTest(

[raymes, 2014/10/15 21:07:09]

It seems a bit nicer to me to avoid having this test code in the implementation.
Instead you could override the ServiceRegistrationManager for test with your own
one that is constructed manually (perhaps with a separate constructor that
doesn't add the services automatically).

[Sam McNally, 2014/10/20 07:21:07]

Done.

+      const base::Callback<void(mojo::InterfaceRequest<Interface>)>& factory) {
+    bool inserted =
+        test_factories_.insert(std::make_pair(
+                                   Interface::Name_,
+                                   linked_ptr<internal::ServiceFactoryBase>(
+                                       new internal::ServiceFactory<Interface>(
+                                           factory)))).second;
+    DCHECK(inserted);
+  }
+
+  // Clears any overrides created using OverrideServiceFactoryForTest().
+  void ClearOverridesForTest();
+
   // Adds the service factories appropriate for |render_frame_host| to its
   // ServiceRegistry.
   void AddToRenderFrame(content::RenderFrameHost* render_frame_host);
 
  private:
   // All factories and their corresponding API permissions.
   std::vector<std::pair<std::string, linked_ptr<internal::ServiceFactoryBase>>>
       factories_;
 
+  std::map<std::string, linked_ptr<internal::ServiceFactoryBase>>
+      test_factories_;
+
   DISALLOW_COPY_AND_ASSIGN(ServiceRegistrationManager);
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_BROWSER_SERVICE_REGISTRATION_MANAGER_H_