Allow platform apps to respond to Web Intents

chrome/browser/extensions/web_intent_callbacks.cc

+// Copyright (c) 2012 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 "base/stringprintf.h"
+#include "chrome/browser/extensions/web_intent_callbacks.h"
+#include "chrome/browser/profiles/profile_dependency_manager.h"
+#include "content/public/browser/web_intents_dispatcher.h"
+
+WebIntentCallbacks::WebIntentCallbacks() {}
+
+WebIntentCallbacks::~WebIntentCallbacks() {}
+
+// static
+WebIntentCallbacks* WebIntentCallbacks::Get(Profile* profile) {
+  return Factory::GetForProfile(profile);
+}
+
+std::string WebIntentCallbacks::RegisterCallback(
+    content::WebIntentsDispatcher* dispatcher) {
+  std::string key = StringPrintf("key_%d", last_id_++);

[Mihai Parparita -not on Chrome, 2012/08/09 04:38:33]

Can keys somehow be scoped by the extension ID of the app that they're intended
for? Otherwise an app could call chrome.experimental.app.postIntentResponse
directly with another app's intent ID to spoof it's response.

Alternatively, you could make it so that postIntentResponse can't be called by
app code by moving it to an internal namespace.

[thorogood, 2012/08/09 09:56:51]

I've taken the first approach, and scoped the key by the extension ID.

+
+  // TODO(thorogood): cleanup task, perhaps we can watch renderer threads.

[Mihai Parparita -not on Chrome, 2012/08/09 04:38:33]

Can you do this cleanup when the launchData object gets GC-ed? There's a
BindToGC native function that you can use in the bindings, see
http://code.google.com/searchframe#OAMlx_jo-ck/src/chrome/renderer/resources/...
for an example.

[thorogood, 2012/08/09 09:56:51]

So I haven't solved this yet, but we talked about it around the office here:
GCing seems to happen unpredictably at some point, and potentially not at all if
the extension were to shut down immediately or due to a crash. So that wouldn't
clear the reference.

Instead: I'm probably going to add a helper class within WebIntentCallbacks that
implements WebContentObserver, and instantiate an instance of that whenever I
invoke RegisterCallback: attaching a unique observer to the WebContents of the
extension page being delivered the intent, for every given pending intent (since
this is a low number). Then when the extension handling the intent goes away, so
does this callback.

On the other flipside, we already mostly deal with the source renderer going
away: WebIntentsDispatcherImpl uses WebContentsObserver to delete its inner
reference to its response mechanism when the source disappears.

+  pending_[key] = dispatcher;
+  return key;
+}
+
+content::WebIntentsDispatcher* WebIntentCallbacks::RetrieveCallback(
+    std::string key) {
+  if (key.empty() || !pending_.count(key))
+    return NULL;
+
+  content::WebIntentsDispatcher* dispatcher = pending_[key];
+  pending_.erase(key);
+  return dispatcher;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Factory boilerplate
+
+// static
+WebIntentCallbacks* WebIntentCallbacks::Factory::GetForProfile(
+    Profile* profile) {
+  return static_cast<WebIntentCallbacks*>(
+      GetInstance()->GetServiceForProfile(profile, true));
+}
+
+WebIntentCallbacks::Factory* WebIntentCallbacks::Factory::GetInstance() {
+  return Singleton<WebIntentCallbacks::Factory>::get();
+}
+
+WebIntentCallbacks::Factory::Factory()
+    : ProfileKeyedServiceFactory("WebIntentCallbacks",
+                                 ProfileDependencyManager::GetInstance()) {
+}
+
+WebIntentCallbacks::Factory::~Factory() {
+}
+
+ProfileKeyedService* WebIntentCallbacks::Factory::BuildServiceInstanceFor(
+    Profile* profile) const {
+  return new WebIntentCallbacks();
+}