Extensions: pass ChromeV8Context around instead of v8::Handle.

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 39 matching lines @@
   }
 
   return true;
 }
 
 const char* kInvalidCallbackIdError = "Invalid callbackId";
 
 }  // namespace
 
 AppBindings::AppBindings(Dispatcher* dispatcher, ChromeV8Context* context)
-    : ChromeV8Extension(dispatcher, context->v8_context()),
+    : ChromeV8Extension(dispatcher, context),
       ChromeV8ExtensionHandler(context) {
   RouteFunction("GetIsInstalled",
       base::Bind(&AppBindings::GetIsInstalled, base::Unretained(this)));
   RouteFunction("GetDetails",
       base::Bind(&AppBindings::GetDetails, base::Unretained(this)));
   RouteFunction("GetDetailsForFrame",
       base::Bind(&AppBindings::GetDetailsForFrame, 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();
+  const Extension* extension = ChromeV8ExtensionHandler::context_->extension();

[not at google - send to devlin, 2013/05/29 15:55:13]

see comment in ObjectBackedNativeHandler: could you call context() here (and
everywhere else) rather than needing to qualify
ChromeV8ExtensionHandler::context_?

[marja, 2013/05/29 16:56:33]

Done.

 
   // TODO(aa): Why only hosted app?
   bool result = extension && extension->is_hosted_app() &&
       dispatcher_->IsExtensionActive(extension->id());
   return v8::Boolean::New(result);
 }
 
 v8::Handle<v8::Value> AppBindings::GetDetails(
     const v8::Arguments& args) {
-  CHECK(context_->web_frame());
-  return GetDetailsForFrameImpl(context_->web_frame());
+  CHECK(ChromeV8ExtensionHandler::context_->web_frame());
+  return GetDetailsForFrameImpl(
+      ChromeV8ExtensionHandler::context_->web_frame());
 }
 
 v8::Handle<v8::Value> AppBindings::GetDetailsForFrame(
     const v8::Arguments& args) {
-  CHECK(context_->web_frame());
-  if (!CheckAccessToAppDetails(context_->web_frame()))
+  CHECK(ChromeV8ExtensionHandler::context_->web_frame());
+  if (!CheckAccessToAppDetails(ChromeV8ExtensionHandler::context_->web_frame()))
     return v8::Undefined();
 
   if (args.Length() < 0)
     return v8::ThrowException(v8::String::New("Not enough arguments."));
 
   if (!args[0]->IsObject()) {
     return v8::ThrowException(
         v8::String::New("Argument 0 must be an object."));
   }
 
@@ skipping 32 matching lines @@
   // 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();
+  content::RenderView* render_view =
+      ChromeV8ExtensionHandler::context_->GetRenderView();
   CHECK(render_view);
 
   Send(new ExtensionHostMsg_GetAppInstallState(
-      render_view->GetRoutingID(), context_->web_frame()->document().url(),
-      GetRoutingID(), callback_id));
+      render_view->GetRoutingID(),
+      ChromeV8ExtensionHandler::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();
+  const WebFrame* parent_frame =
+      ChromeV8ExtensionHandler::context_->web_frame();
   while (parent_frame->parent())
     parent_frame = parent_frame->parent();
 
   const ExtensionSet* extensions = dispatcher_->extensions();
 
   // 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()));
+  const Extension* this_app = extensions->GetHostedAppByURL(ExtensionURLInfo(
+      ChromeV8ExtensionHandler::context_->web_frame()->document().url()));
 
   if (!this_app || !parent_app)
     return v8::String::New(extension_misc::kAppStateCannotRun);
 
   const char* state = NULL;
   if (dispatcher_->IsExtensionActive(parent_app->id())) {
     if (parent_app == this_app)
       state = extension_misc::kAppStateRunning;
     else
       state = extension_misc::kAppStateCannotRun;
@@ skipping 11 matching lines @@
     IPC_MESSAGE_HANDLER(ExtensionMsg_GetAppInstallStateResponse,
                         OnAppInstallStateResponse)
     IPC_MESSAGE_UNHANDLED(CHECK(false) << "Unhandled IPC message")
   IPC_END_MESSAGE_MAP()
   return true;
 }
 
 void AppBindings::OnAppInstallStateResponse(
     const std::string& state, int callback_id) {
   v8::HandleScope handle_scope;
-  v8::Context::Scope context_scope(context_->v8_context());
+  v8::Context::Scope context_scope(
+      ChromeV8ExtensionHandler::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));
+  CHECK(ChromeV8ExtensionHandler::context_->CallChromeHiddenMethod(
+      "app.onInstallStateResponse", arraysize(argv), argv, NULL));
 }
 
 }  // namespace extensions