Add js api for hosted/pacakged apps to request notification authorization

chrome/renderer/extensions/chrome_app_bindings.cc

 // Copyright (c) 2011 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 "chrome/renderer/extensions/chrome_app_bindings.h"
 
 #include "base/command_line.h"
 #include "base/json/json_writer.h"
 #include "base/string16.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension_set.h"
 #include "chrome/renderer/extensions/extension_dispatcher.h"
 #include "chrome/renderer/extensions/extension_helper.h"
+#include "chrome/renderer/weak_v8_function_map.h"
 #include "content/public/renderer/v8_value_converter.h"
 #include "content/renderer/render_view.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "v8/include/v8.h"
 
 using WebKit::WebFrame;
 using content::V8ValueConverter;
 
 namespace {
@@ skipping 18 matching lines @@
   if (!IsCheckoutURL(frame->document().url().spec())) {
     std::string error("Access denied for URL: ");
     error += frame->document().url().spec();
     v8::ThrowException(v8::String::New(error.c_str()));
     return false;
   }
 
   return true;
 }
 
+int g_next_request_id = 0;
+base::LazyInstance<WeakV8FunctionMap> g_callbacks(base::LINKER_INITIALIZED);
+
+const char* kMissingClientIdError = "Missing clientId parameter";
+const char* kInvalidClientIdError = "Invalid clientId";
+const char* kCallbackNotAFunctionError =
+    "The callback that was passed is not a function";
+
 }  // namespace
 
 const char kAppExtensionName[] = "v8/ChromeApp";
 
 namespace extensions_v8 {
 
 class ChromeAppExtensionWrapper : public v8::Extension {
  public:
   explicit ChromeAppExtensionWrapper(ExtensionDispatcher* extension_dispatcher)
       : v8::Extension(
             kAppExtensionName,
             "var chrome;"
             "if (!chrome)"
             "  chrome = {};"
             "if (!chrome.app) {"
             "  chrome.app = new function() {"
             "    native function GetIsInstalled();"
             "    native function Install();"
             "    native function GetDetails();"
             "    native function GetDetailsForFrame();"
+            "    native function GetAppNotifyChannel();"
             "    this.__defineGetter__('isInstalled', GetIsInstalled);"
             "    this.install = Install;"
             "    this.getDetails = GetDetails;"
             "    this.getDetailsForFrame = GetDetailsForFrame;"
+            "    this.experimental = {};"
+            "    this.experimental.getNotificationChannel ="
+            "        GetAppNotifyChannel;"
             "  };"
             "}") {
     extension_dispatcher_ = extension_dispatcher;
   }
 
   ~ChromeAppExtensionWrapper() {
     extension_dispatcher_ = NULL;
   }
 
   virtual v8::Handle<v8::FunctionTemplate> GetNativeFunction(
       v8::Handle<v8::String> name) {
     if (name->Equals(v8::String::New("GetIsInstalled"))) {
       return v8::FunctionTemplate::New(GetIsInstalled);
     } else if (name->Equals(v8::String::New("Install"))) {
       return v8::FunctionTemplate::New(Install);
     } else if (name->Equals(v8::String::New("GetDetails"))) {
       return v8::FunctionTemplate::New(GetDetails);
     } else if (name->Equals(v8::String::New("GetDetailsForFrame"))) {
       return v8::FunctionTemplate::New(GetDetailsForFrame);
+    } else if (name->Equals(v8::String::New("GetAppNotifyChannel"))) {
+      return v8::FunctionTemplate::New(GetAppNotifyChannel);
     } else {
       return v8::Handle<v8::FunctionTemplate>();
     }
   }
 
   static v8::Handle<v8::Value> GetIsInstalled(const v8::Arguments& args) {
     WebFrame* frame = WebFrame::frameForCurrentContext();
     if (!frame)
       return v8::False();
 
@@ skipping 65 matching lines @@
       return v8::Null();
 
     scoped_ptr<DictionaryValue> manifest_copy(
         extension->manifest_value()->DeepCopy());
     manifest_copy->SetString("id", extension->id());
     scoped_ptr<V8ValueConverter> converter(V8ValueConverter::create());
     return converter->ToV8Value(manifest_copy.get(),
                                frame->mainWorldScriptContext());
   }
 
+  static v8::Handle<v8::Value> GetAppNotifyChannel(const v8::Arguments& args) {
+    WebFrame* frame = WebFrame::frameForCurrentContext();
+    if (!frame || !frame->view())
+      return v8::Undefined();
+
+    RenderView* render_view = RenderView::FromWebView(frame->view());
+    if (!render_view)
+      return v8::Undefined();
+
+    if (g_next_request_id < 0)
+      return v8::Undefined();
+    int request_id = g_next_request_id++;
+
+    // Read the required 'clientId' value out of the object at args[0].
+    std::string client_id;
+    if (args.Length() < 1 || !args[0]->IsObject()) {
+      v8::ThrowException(v8::String::New(kMissingClientIdError));
+      return v8::Undefined();
+    }
+    v8::Local<v8::Object> obj = v8::Local<v8::Object>::Cast(args[0]);
+    v8::Local<v8::String> client_id_key = v8::String::New("clientId");
+    if (obj->Has(client_id_key)) {
+      v8::String::Utf8Value id_value(obj->Get(client_id_key));
+      if (id_value.length() > 0)
+        client_id = std::string(*id_value);
+    }
+    if (client_id.empty()) {
+      v8::ThrowException(v8::String::New(kInvalidClientIdError));
+      return v8::Undefined();
+    }
+
+    // Hang on to the callback if there was one.
+    if (args.Length() >= 2) {
+      if (args[1]->IsFunction()) {
+        g_callbacks.Get().Add(request_id, v8::Function::Cast(*args[1]));
+      } else {
+        v8::ThrowException(v8::String::New(kCallbackNotAFunctionError));
+        return v8::Undefined();
+      }
+    }
+
+    ExtensionHelper* helper = ExtensionHelper::Get(render_view);
+    helper->GetAppNotifyChannel(
+        request_id, frame->document().url(), client_id);
+    return v8::Undefined();
+  }
+
   static ExtensionDispatcher* extension_dispatcher_;
 };
 
 ExtensionDispatcher* ChromeAppExtensionWrapper::extension_dispatcher_;
 
 v8::Extension* ChromeAppExtension::Get(
     ExtensionDispatcher* extension_dispatcher) {
   return new ChromeAppExtensionWrapper(extension_dispatcher);
 }
 
+void ChromeAppExtension::HandleGetAppNotifyChannelResponse(
+    int request_id, const std::string& channel_id, const std::string& error) {
+  v8::Persistent<v8::Function> function = g_callbacks.Get().Remove(request_id);
+  if (function.IsEmpty())
+    return;
+  v8::HandleScope handle_scope;
+  v8::Context::Scope context_scope(function->CreationContext());
+  v8::Handle<v8::Value> argv[2];
+  argv[0] = v8::String::New(channel_id.c_str());
+  argv[1] = v8::String::New(error.c_str());
+  function->Call(v8::Object::New(), arraysize(argv), argv);
+}
+
 }  // namespace extensions_v8