Add an API for hosted apps to check their install and running states.

chrome/renderer/extensions/app_bindings.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 "chrome/renderer/extensions/app_bindings.h"
 
 #include "base/command_line.h"
 #include "base/string16.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
@@ skipping 51 matching lines @@
   RouteFunction("GetIsInstalled",
       base::Bind(&AppBindings::GetIsInstalled, base::Unretained(this)));
   RouteFunction("Install",
       base::Bind(&AppBindings::Install, base::Unretained(this)));
   RouteFunction("GetDetails",
       base::Bind(&AppBindings::GetDetails, base::Unretained(this)));
   RouteFunction("GetDetailsForFrame",
       base::Bind(&AppBindings::GetDetailsForFrame, base::Unretained(this)));
   RouteFunction("GetAppNotifyChannel",
       base::Bind(&AppBindings::GetAppNotifyChannel, base::Unretained(this)));
+  RouteFunction("GetInstallState",
+      base::Bind(&AppBindings::GetInstallState, base::Unretained(this)));
+  RouteFunction("GetRunningState",
+      base::Bind(&AppBindings::GetRunningState, base::Unretained(this)));
 }
 
 v8::Handle<v8::Value> AppBindings::GetIsInstalled(
     const v8::Arguments& args) {
   const Extension* extension = context_->extension();
 
   // TODO(aa): Why only hosted app?
   bool result = extension && extension->is_hosted_app() &&
       extension_dispatcher_->IsExtensionActive(extension->id());
   return v8::Boolean::New(result);
@@ skipping 95 matching lines @@
 
   content::RenderView* render_view = context_->GetRenderView();
   CHECK(render_view);
 
   Send(new ExtensionHostMsg_GetAppNotifyChannel(
       render_view->GetRoutingID(), context_->web_frame()->document().url(),
       client_id, GetRoutingID(), callback_id));
   return v8::Undefined();
 }
 
+v8::Handle<v8::Value> AppBindings::GetInstallState(const v8::Arguments& args) {
+  // Get the callbackId.
+  int callback_id = 0;
+  if (args.Length() == 1) {
+    if (!args[0]->IsInt32()) {
+      v8::ThrowException(v8::String::New(kInvalidCallbackIdError));
+      return v8::Undefined();
+    }
+    callback_id = args[0]->Int32Value();
+  }
+
+  content::RenderView* render_view = context_->GetRenderView();
+  CHECK(render_view);
+
+  Send(new ExtensionHostMsg_GetAppInstallState(
+      render_view->GetRoutingID(), context_->web_frame()->document().url(),
+      GetRoutingID(), callback_id));
+  return v8::Undefined();
+}
+
+v8::Handle<v8::Value> AppBindings::GetRunningState(const v8::Arguments& args) {
+  // To distinguish between ready_to_run and cannot_run states, we need the top
+  // level frame.
+  const WebFrame* parent_frame = context_->web_frame();
+  while (parent_frame->parent())
+    parent_frame = parent_frame->parent();
+
+  ExtensionURLInfo strict_url(parent_frame->document().securityOrigin(),
+                              context_->web_frame()->document().url());
+
+  const ExtensionSet* extensions = extension_dispatcher_->extensions();
+  const Extension* extension = extensions->GetExtensionOrAppByURL(strict_url);
+  const char* state = NULL;
+
+  if (extension) {
+    if (extension_dispatcher_->IsExtensionActive(extension->id()))
+      state = extension_misc::kAppStateRunning;
+    else
+      state = extension_misc::kAppStateReadyToRun;
+  } else {
+    state = extension_misc::kAppStateCannotRun;
+  }
+
+  return v8::String::New(state);
+}
+
 bool AppBindings::OnMessageReceived(const IPC::Message& message) {
   IPC_BEGIN_MESSAGE_MAP(AppBindings, message)
     IPC_MESSAGE_HANDLER(ExtensionMsg_GetAppNotifyChannelResponse,
                         OnGetAppNotifyChannelResponse)
+    IPC_MESSAGE_HANDLER(ExtensionMsg_GetAppInstallStateResponse,
+                        OnAppInstallStateResponse)
     IPC_MESSAGE_UNHANDLED(CHECK(false) << "Unhandled IPC message")
   IPC_END_MESSAGE_MAP()
   return true;
 }
 
 void AppBindings::OnGetAppNotifyChannelResponse(
     const std::string& channel_id, const std::string& error, int callback_id) {
   v8::HandleScope handle_scope;
   v8::Context::Scope context_scope(context_->v8_context());
   v8::Handle<v8::Value> argv[3];
   argv[0] = v8::String::New(channel_id.c_str());
   argv[1] = v8::String::New(error.c_str());
   argv[2] = v8::Integer::New(callback_id);
   CHECK(context_->CallChromeHiddenMethod("app.onGetAppNotifyChannelResponse",
                                          arraysize(argv), argv, NULL));
 }
+
+void AppBindings::OnAppInstallStateResponse(
+    const std::string& state, int callback_id) {
+  v8::HandleScope handle_scope;
+  v8::Context::Scope context_scope(context_->v8_context());
+  v8::Handle<v8::Value> argv[2];
+  argv[0] = v8::String::New(state.c_str());
+  argv[1] = v8::Integer::New(callback_id);
+  CHECK(context_->CallChromeHiddenMethod("app.onInstallStateResponse",
+                                         arraysize(argv), argv, NULL));
+}