[gin] Allow interceptors to signal whether a they intercepted something

gin/interceptor_unittest.cc

 // Copyright 2014 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 "base/logging.h"
 #include "gin/arguments.h"
 #include "gin/handle.h"
 #include "gin/interceptor.h"
 #include "gin/object_template_builder.h"
 #include "gin/per_isolate_data.h"
@@ skipping 24 matching lines @@
                                                 const std::string& property)
       OVERRIDE {
     if (property == "value") {
       return ConvertToV8(isolate, value_);
     } else if (property == "func") {
       return GetFunctionTemplate(isolate, "func")->GetFunction();
     } else {
       return v8::Local<v8::Value>();
     }
   }
-  virtual void SetNamedProperty(v8::Isolate* isolate,
+  virtual bool SetNamedProperty(v8::Isolate* isolate,
                                 const std::string& property,
                                 v8::Local<v8::Value> value) OVERRIDE {
-    if (property != "value")
-      return;
-    ConvertFromV8(isolate, value, &value_);
+    if (property == "value") {
+      ConvertFromV8(isolate, value, &value_);
+      return true;
+    }
+    return false;
   }
   virtual std::vector<std::string> EnumerateNamedProperties(
       v8::Isolate* isolate) OVERRIDE {
     std::vector<std::string> result;
     result.push_back("func");
     result.push_back("value");
     return result;
   }
 
   // gin::IndexedPropertyInterceptor
   virtual v8::Local<v8::Value> GetIndexedProperty(v8::Isolate* isolate,
                                                   uint32_t index) OVERRIDE {
     if (index == 0)
       return ConvertToV8(isolate, value_);
     return v8::Local<v8::Value>();
   }
-  virtual void SetIndexedProperty(v8::Isolate* isolate,
+  virtual bool SetIndexedProperty(v8::Isolate* isolate,
                                   uint32_t index,
                                   v8::Local<v8::Value> value) OVERRIDE {
-    if (index != 0)
-      return;
-    ConvertFromV8(isolate, value, &value_);
+    if (index == 0) {
+      ConvertFromV8(isolate, value, &value_);
+      return true;
+    }
+    // Don't allow bypassing the interceptor.
+    return true;
   }
   virtual std::vector<uint32_t> EnumerateIndexedProperties(v8::Isolate* isolate)
       OVERRIDE {
     std::vector<uint32_t> result;
     result.push_back(0);
     return result;
   }
 
  private:
   explicit MyInterceptor(v8::Isolate* isolate)
@@ skipping 82 matching lines @@
       "   })");
 }
 
 TEST_F(InterceptorTest, IndexedInterceptor) {
   RunInterceptorTest(
       "(function (obj) {"
       "   if (obj[0] !== 42) throw 'FAIL';"
       "   else obj[0] = 191; })");
 }
 
+TEST_F(InterceptorTest, BypassInterceptorAllowed) {
+  RunInterceptorTest(
+      "(function (obj) {"
+      "   obj.value = 191 /* make test happy */;"
+      "   obj.foo = 23;"
+      "   if (obj.foo !== 23) throw 'FAIL'; })");
+}
+
+TEST_F(InterceptorTest, BypassInterceptorForbidden) {
+  RunInterceptorTest(
+      "(function (obj) {"
+      "   obj.value = 191 /* make test happy */;"
+      "   obj[1] = 23;"
+      "   if (obj[1] === 23) throw 'FAIL'; })");
+}
+
 }  // namespace gin