mojo: Update content handler API

mojo/application/content_handler.h

Index: mojo/application/content_handler.h
diff --git a/mojo/application/content_handler.h b/mojo/application/content_handler.h
new file mode 100644
index 0000000000000000000000000000000000000000..5173f8cf96a496d6a91ed53070801387680db7c7
--- /dev/null
+++ b/mojo/application/content_handler.h
@@ -0,0 +1,65 @@
+// 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_APPLICATION_CONTENT_HANDLER_H_
+#define MOJO_APPLICATION_CONTENT_HANDLER_H_
+
+#include "base/memory/scoped_ptr.h"
+#include "mojo/public/cpp/application/interface_factory.h"
+#include "mojo/public/interfaces/application/shell.mojom.h"
+#include "mojo/services/public/interfaces/content_handler/content_handler.mojom.h"
+#include "mojo/services/public/interfaces/network/url_loader.mojom.h"
+
+namespace mojo {
+
+class ContentHandlerFactory : public InterfaceFactory<ContentHandler> {
+ public:
+  class HandledApplicationHolder {

[qsr, 2014/10/31 12:10:44]

I don't really like this, but I'm a little bit out of idea, so any suggestion
welcome:

 What I need is that CreateApplication returns an object that will be owned by
the caller, but all the caller care about is the life cycle, it will not call
any method on it or anything. It just needs to keep it alive until the run loop
is quit. I didn't find any other way than forcing this class and having a
templated factory that take a class an create such a holder. But this is kind of
ugly.

[Aaron Boodman, 2014/10/31 16:40:46]

You could have apps be responsible for deleting themselves when they exit the
message loop. That's only thing I can think of. (well you could templatize a lot
more of the code in the cc file, but I think that would be worse)

Otherwise, I think you can remove make_handled_factory_holder. Doesn't this
work:

return scoped_ptr<HandledApplicationHolder>(new MyApp());

(assuming MyApp inherits HandledApplicationHolder).

Also, consider renaming HandledApplicationHolder to "Destructable" or some such,
since that's all it is really doing.

+   public:
+    virtual ~HandledApplicationHolder() {}
+  };
+
+  class Delegate {
+   public:
+    virtual ~Delegate() {}
+    // Implement this method to create the Application for the given
+    // content. The application will be run on its own thread, and the returned
+    // value will be kept alive until the application ends.
+    virtual scoped_ptr<HandledApplicationHolder> CreateApplication(
+        ShellPtr shell,
+        URLResponsePtr response) = 0;
+  };
+
+  explicit ContentHandlerFactory(Delegate* delegate);
+  virtual ~ContentHandlerFactory();
+
+ private:
+  // From InterfaceFactory:
+  virtual void Create(ApplicationConnection* connection,
+                      InterfaceRequest<ContentHandler> request) override;
+
+  Delegate* delegate_;
+
+  DISALLOW_COPY_AND_ASSIGN(ContentHandlerFactory);
+};
+
+template <class A>
+class HandledApplicationHolderImpl
+    : public ContentHandlerFactory::HandledApplicationHolder {
+ public:
+  explicit HandledApplicationHolderImpl(A* value) : value_(value) {}
+
+ private:
+  scoped_ptr<A> value_;
+};
+
+template <class A>
+scoped_ptr<ContentHandlerFactory::HandledApplicationHolder>
+make_handled_factory_holder(A* value) {
+  return make_scoped_ptr(new HandledApplicationHolderImpl<A>(value));
+}
+
+}  // namespace mojo
+
+#endif  // MOJO_APPLICATION_CONTENT_HANDLER_H_