First cut at "content handling" support in Mojo.

mojo/service_manager/service_loader.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 MOJO_SERVICE_MANAGER_SERVICE_LOADER_H_
 #define MOJO_SERVICE_MANAGER_SERVICE_LOADER_H_
 
+#include "base/memory/ref_counted.h"
 #include "mojo/public/cpp/system/core.h"
 #include "mojo/service_manager/service_manager_export.h"
+#include "mojo/services/public/interfaces/network/url_loader.mojom.h"
 #include "url/gurl.h"
 
 namespace mojo {
 
 class ServiceManager;
 
 // Interface to allowing loading behavior to be established for schemes,
 // specific urls or as the default.
 // A ServiceLoader is responsible to using whatever mechanism is appropriate
 // to load the application at url.
 // TODO(davemoore): change name to ApplicationLoader.
 // The handle to the shell is passed to that application so it can bind it to
 // a Shell instance. This will give the Application a way to connect to other
 // apps and services.
 class MOJO_SERVICE_MANAGER_EXPORT ServiceLoader {
  public:
+  class LoadServiceCallbacks : public base::RefCounted<LoadServiceCallbacks> {

[darin (slow to review), 2014/08/06 23:10:02]

nit: you might consider just naming this class Callbacks since "LoadService" is
a bit redundant with the containing class name ServiceLoader. Another option is
to rename the LoadService method to just be Load and name this callbacks class
LoadCallbacks. That way you preserve the relationship between the method and the
callbacks class, and you get to have shorter names.

[Aaron Boodman, 2014/08/07 00:03:12]

I like the second idea. Done.

+   public:
+    // Register the requested application with ServiceManager. If the returned
+    // handle is valid, it should be used to implement the mojo::Application
+    // interface.
+    virtual ScopedMessagePipeHandle RegisterApplication() = 0;
+
+    // Load the requested application with a content handler.
+    virtual void LoadWithContentHandler(const GURL& content_handler_url,
+                                        URLResponsePtr response) = 0;
+   protected:
+    friend base::RefCounted<LoadServiceCallbacks>;
+    virtual ~LoadServiceCallbacks() {}
+  };
+
+  // Implements RegisterApplication() by returning a handle that was specified
+  // at construction time. LoadWithContentHandler() is not supported.
+  class SimpleLoadServiceCallbacks : public LoadServiceCallbacks {
+   public:
+    SimpleLoadServiceCallbacks(ScopedMessagePipeHandle shell_handle);
+    virtual ScopedMessagePipeHandle RegisterApplication() OVERRIDE;
+    virtual void LoadWithContentHandler(const GURL& content_handler_url,
+                                        URLResponsePtr response) OVERRIDE;
+   private:
+    ScopedMessagePipeHandle shell_handle_;
+    virtual ~SimpleLoadServiceCallbacks();
+  };
+
   virtual ~ServiceLoader() {}
-  virtual void LoadService(ServiceManager* manager,
+
+  // Load the application named |url|. Applications can be loaded two ways:
+  //
+  // 1. |url| can refer directly to a Mojo application. In this case, call
+  //    callbacks->RegisterApplication(). The returned handle should be used to
+  //    implement the mojo.Application interface. Note that the returned handle
+  //    can be invalid in the case where the application has already been
+  //    loaded.
+  //
+  // 2. |url| can refer to some content that can be handled by some other Mojo
+  //    application. In this case, call callbacks->LoadWithContentHandler() and
+  //    specify the URL of the application that should handle the content.
+  //    The specified application must implement the mojo.ContentHandler
+  //    interface.
+  virtual void LoadService(ServiceManager* service_manager,

[darin (slow to review), 2014/08/06 23:10:01]

nit: this method could just be called Load

[Aaron Boodman, 2014/08/07 00:03:12]

Done.

                            const GURL& url,
-                           ScopedMessagePipeHandle shell_handle) = 0;
+                           scoped_refptr<LoadServiceCallbacks> callbacks) = 0;
+
   virtual void OnServiceError(ServiceManager* manager, const GURL& url) = 0;
 
  protected:
   ServiceLoader() {}
 };
 
 }  // namespace mojo
 
 #endif  // MOJO_SERVICE_MANAGER_SERVICE_LOADER_H_