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();
+
+  const ExtensionSet* extensions = extension_dispatcher_->extensions();
+  const char* state = NULL;
+
+  // The app associated with the top level frame.
+  const Extension* parent_app = extensions->GetHostedAppByURL(
+      ExtensionURLInfo(parent_frame->document().url()));
+
+  // The app associated with this frame.
+  const Extension* this_app = extensions->GetHostedAppByURL(
+      ExtensionURLInfo(context_->web_frame()->document().url()));
+
+  if (!this_app || !parent_app) {
+    state = extension_misc::kAppStateCannotRun;
+    return v8::String::New(state);

[miket_OOO, 2012/04/24 00:04:48]

Just for clarity, can you move state's declaration below this code block and put
the constant string in the String::New() function call inside this code block?

The reason is that I always scrutinize early exits in functions, and it was
confusing to see state manipulated in this block with an immediate exit. It'd be
less confusing if state didn't even come into existence after this block.

[jstritar, 2012/04/24 00:11:59]

Done.

+  }
+
+  if (extension_dispatcher_->IsExtensionActive(parent_app->id())) {
+    if (parent_app == this_app)
+      state = extension_misc::kAppStateRunning;
+    else
+      state = extension_misc::kAppStateCannotRun;
+  } else if (parent_app == this_app) {
+    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));
+}