Make presubmit script happy again.

include/v8-util.h

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_UTIL_H_
 #define V8_UTIL_H_
 
 #include "v8.h"
 #include <map>
 #include <vector>
@@ skipping 136 matching lines @@
   bool Contains(const K& key) {
     return Traits::Get(&impl_, key) != kPersistentContainerNotFound;
   }
 
   /**
    * Get value stored in map and set it in returnValue.
    * Return true if a value was found.
    */
   bool SetReturnValue(const K& key,
       ReturnValue<Value> returnValue) {
-    return SetReturnValueFromVal(returnValue, Traits::Get(&impl_, key));
+    return SetReturnValueFromVal(&returnValue, Traits::Get(&impl_, key));
   }
 
   /**
    * Call Isolate::SetReference with the given parent and the map value.
    */
   void SetReference(const K& key,
       const Persistent<Object>& parent) {
     GetIsolate()->SetReference(
       reinterpret_cast<internal::Object**>(parent.val_),
       reinterpret_cast<internal::Object**>(FromVal(Traits::Get(&impl_, key))));
@@ skipping 52 matching lines @@
         : value_(other.value_) { }
 
     Local<V> NewLocal(Isolate* isolate) const {
       return Local<V>::New(isolate, FromVal(value_));
     }
     bool IsEmpty() const {
       return value_ == kPersistentContainerNotFound;
     }
     template<typename T>
     bool SetReturnValue(ReturnValue<T> returnValue) {
-      return SetReturnValueFromVal(returnValue, value_);
+      return SetReturnValueFromVal(&returnValue, value_);
     }
     void Reset() {
       value_ = kPersistentContainerNotFound;
     }
     void operator=(const PersistentValueReference& other) {
       value_ = other.value_;
     }
 
    private:
     friend class PersistentValueMap;
@@ skipping 61 matching lines @@
                       persistentValueMap->Remove(key).Pass(), key);
       Traits::DisposeCallbackData(data.GetParameter());
     }
   }
 
   static V* FromVal(PersistentContainerValue v) {
     return reinterpret_cast<V*>(v);
   }
 
   static bool SetReturnValueFromVal(
-      ReturnValue<Value>& returnValue, PersistentContainerValue value) {
+      ReturnValue<Value>* returnValue, PersistentContainerValue value) {
     bool hasValue = value != kPersistentContainerNotFound;
     if (hasValue) {
-      returnValue.SetInternal(
+      returnValue->SetInternal(
           *reinterpret_cast<internal::Object**>(FromVal(value)));
     }
     return hasValue;
   }
 
   static PersistentContainerValue ClearAndLeak(
       UniquePersistent<V>* persistent) {
     V* v = persistent->val_;
     persistent->val_ = 0;
     return reinterpret_cast<PersistentContainerValue>(v);
@@ skipping 152 matching lines @@
     return reinterpret_cast<V*>(v);
   }
 
   Isolate* isolate_;
   typename Traits::Impl impl_;
 };
 
 }  // namespace v8
 
 #endif  // V8_UTIL_H_