First cut at "content handling" support in Mojo.

mojo/shell/dynamic_service_loader.h

Index: mojo/shell/dynamic_service_loader.h
diff --git a/mojo/shell/dynamic_service_loader.h b/mojo/shell/dynamic_service_loader.h
index 72bf093e56e093809a83cd8d3a934f904cf12bca..4c3445dff0d601217e9f73cecf1e176c81e786cc 100644
--- a/mojo/shell/dynamic_service_loader.h
+++ b/mojo/shell/dynamic_service_loader.h
@@ -8,6 +8,7 @@
 #include <map>
 
 #include "base/macros.h"
+#include "base/memory/weak_ptr.h"
 #include "mojo/public/cpp/system/core.h"
 #include "mojo/service_manager/service_loader.h"
 #include "mojo/services/public/interfaces/network/network_service.mojom.h"
@@ -30,17 +31,38 @@ class DynamicServiceLoader : public ServiceLoader {
                        scoped_ptr<DynamicServiceRunnerFactory> runner_factory);
   virtual ~DynamicServiceLoader();
 
+  void set_content_handler(const std::string& mime_type,
+                           const GURL& content_handler_url);

[DaveMoore, 2014/08/06 20:50:46]

SetContentHandlerURL() or SetContentHandlerURLForMimeType()

Also, I think this may belong on the ServiceManager, not within the
DynamicServiceLoader

[Aaron Boodman, 2014/08/06 22:49:29]

I looked at doing this, but it makes ownership of the |response| param  to
LoadServiceCallbacks::LoadWithContentHandler() conditional on the success of the
function:

bool LoadServiceCallbacksImpl::LoadWithContentHandler(
    URLResponsePtr* response) {

  MimeTypeToContentHandler::iterator iter = 
      mime_type_to_content_handler_.find(response->mime_type);
  if (iter == mime_type_to_content_handler_.end()) {
    // Caller retains ownership of |response|.
    return;
  }

  // We take ownership of |response|.
  URLResponsePtr owned_response = response->Pass();

  ...
}

There are a few more speculative problems I can forsee with having this in SM:

1) When figuring out the right handler requires sniffing the beginning of the
data (as it does on the web), then LoadWithContentHandler() will need to consume
some of the response. But if it fails, then it needs to return that consumed
data back to the caller somehow so that the caller can use it to run the DSO.

2) I suspect that finding the right content handler isn't going to be as much of
a global map of mimetype->handler as it looks like in this change. Think of this
as temporary scaffolding. The mapping of content type to handler might not even
live in the shell ... it might be a feature of the window manager, since really
that's where it's needed. When applications are just randomly wanting to 

Anyway, I'd be happy to just go ahead with your idea see how the code evolves if
it wasn't more complex. But since it is more complex I'd prefer to stick with
the current design for now (pending Darin's comments, anyway).

+
   // ServiceLoader methods:
-  virtual void LoadService(ServiceManager* manager,
-                           const GURL& url,
-                           ScopedMessagePipeHandle service_handle) OVERRIDE;
+  virtual void LoadService(
+      ServiceManager* manager,
+      const GURL& url,
+      scoped_refptr<LoadServiceCallbacks> callbacks) OVERRIDE;
   virtual void OnServiceError(ServiceManager* manager, const GURL& url)
       OVERRIDE;
 
  private:
+  typedef std::map<std::string, GURL> MimeTypeToURLMap;
+
+  void LoadLocalService(const GURL& resolved_url,
+                        scoped_refptr<LoadServiceCallbacks> callbacks);
+  void LoadNetworkService(const GURL& resolved_url,
+                          scoped_refptr<LoadServiceCallbacks> callbacks);
+  void OnLoadNetworkServiceComplete(
+      scoped_refptr<LoadServiceCallbacks> callbacks,
+      URLResponsePtr url_response);
+  void RunLibrary(const base::FilePath& response_file,
+                  scoped_refptr<LoadServiceCallbacks> callbacks,
+                  bool delete_file_after,
+                  bool response_path_exists);
+
   Context* const context_;
   scoped_ptr<DynamicServiceRunnerFactory> runner_factory_;
   NetworkServicePtr network_service_;
+  URLLoaderPtr url_loader_;
+  MimeTypeToURLMap mime_type_to_url_;
+  base::WeakPtrFactory<DynamicServiceLoader> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(DynamicServiceLoader);
 };