Remove usage of deprecated V8 APIs from c/r/extensions

chrome/renderer/extensions/messaging_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/messaging_bindings.h"
 
 #include <map>
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 91 matching lines @@
     if (!renderview)
       return;
 
     // Arguments are (int32 port_id, string message).
     CHECK(args.Length() == 2 &&
           args[0]->IsInt32() &&
           args[1]->IsString());
 
     int port_id = args[0]->Int32Value();
     if (!HasPortData(port_id)) {
-      v8::ThrowException(v8::Exception::Error(
+      args.GetIsolate()->ThrowException(v8::Exception::Error(
           v8::String::NewFromUtf8(args.GetIsolate(), kPortClosedError)));
       return;
     }
 
     renderview->Send(new ExtensionHostMsg_PostMessage(
         renderview->GetRoutingID(), port_id,
         extensions::Message(
-            *v8::String::AsciiValue(args[1]),
+            *v8::String::Utf8Value(args[1]),
             blink::WebUserGestureIndicator::isProcessingUserGesture())));
   }
 
   // Forcefully disconnects a port.
   void CloseChannel(const v8::FunctionCallbackInfo<v8::Value>& args) {
     // Arguments are (int32 port_id, boolean notify_browser).
     CHECK_EQ(2, args.Length());
     CHECK(args[0]->IsInt32());
     CHECK(args[1]->IsBoolean());
 
@@ skipping 40 matching lines @@
   }
 
   // Holds a |callback| to run sometime after |object| is GC'ed. |callback| will
   // not be executed re-entrantly to avoid running JS in an unexpected state.
   class GCCallback {
    public:
     static void Bind(v8::Handle<v8::Object> object,
                      v8::Handle<v8::Function> callback,
                      v8::Isolate* isolate) {
       GCCallback* cb = new GCCallback(object, callback, isolate);
-      cb->object_.MakeWeak(cb, NearDeathCallback);
+      cb->object_.SetWeak(cb, NearDeathCallback);
     }
 
    private:
-    static void NearDeathCallback(v8::Isolate* isolate,
-                                  v8::Persistent<v8::Object>* object,
-                                  GCCallback* self) {
+    static void NearDeathCallback(
+        const v8::WeakCallbackData<v8::Object, GCCallback>& data) {
       // v8 says we need to explicitly reset weak handles from their callbacks.
       // It's not implicit as one might expect.
-      self->object_.reset();
-      base::MessageLoop::current()->PostTask(FROM_HERE,
-          base::Bind(&GCCallback::RunCallback, base::Owned(self)));
+      data.GetParameter()->object_.reset();
+      base::MessageLoop::current()->PostTask(
+          FROM_HERE,
+          base::Bind(&GCCallback::RunCallback,
+                     base::Owned(data.GetParameter())));
     }
 
     GCCallback(v8::Handle<v8::Object> object,
                v8::Handle<v8::Function> callback,
                v8::Isolate* isolate)
         : object_(object), callback_(callback), isolate_(isolate) {}
 
     void RunCallback() {
       v8::HandleScope handle_scope(isolate_);
       v8::Handle<v8::Function> callback = callback_.NewHandle(isolate_);
@@ skipping 59 matching lines @@
        it != contexts.end(); ++it) {
     if (restrict_to_render_view &&
         restrict_to_render_view != (*it)->GetRenderView()) {
       continue;
     }
 
     // TODO(kalman): remove when ContextSet::ForEach is available.
     if ((*it)->v8_context().IsEmpty())
       continue;
 
-    v8::Handle<v8::Value> tab = v8::Null();
+    v8::Handle<v8::Value> tab = v8::Null(isolate);
     if (!source_tab.empty())
       tab = converter->ToV8Value(&source_tab, (*it)->v8_context());
 
-    v8::Handle<v8::Value> tls_channel_id_value = v8::Undefined();
+    v8::Handle<v8::Value> tls_channel_id_value = v8::Undefined(isolate);
     if ((*it)->extension()) {
       ExternallyConnectableInfo* externally_connectable =
           ExternallyConnectableInfo::Get((*it)->extension());
       if (externally_connectable &&
           externally_connectable->accepts_tls_channel_id) {
         tls_channel_id_value =
             v8::String::NewFromUtf8(isolate,
                                     tls_channel_id.c_str(),
                                     v8::String::kNormalString,
                                     tls_channel_id.size());
@@ skipping 113 matching lines @@
     // TODO(kalman): remove when ContextSet::ForEach is available.
     if ((*it)->v8_context().IsEmpty())
       continue;
 
     std::vector<v8::Handle<v8::Value> > arguments;
     arguments.push_back(v8::Integer::New(port_id));
     if (!error_message.empty()) {
       arguments.push_back(
           v8::String::NewFromUtf8(isolate, error_message.c_str()));
     } else {
-      arguments.push_back(v8::Null());
+      arguments.push_back(v8::Null(isolate));
     }
     (*it)->module_system()->CallModuleMethod("messaging",
                                              "dispatchOnDisconnect",
                                              &arguments);
   }
 }
 
 }  // namespace extensions