Move securityCheck out of V8WrapperInstantiationScope

third_party/WebKit/Source/bindings/core/v8/V8DOMWrapper.h

 /*
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 13 matching lines @@
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef V8DOMWrapper_h
 #define V8DOMWrapper_h
 
-#include "bindings/core/v8/BindingSecurity.h"
 #include "bindings/core/v8/DOMDataStore.h"
 #include "bindings/core/v8/ScriptWrappable.h"
 #include "bindings/core/v8/V8Binding.h"
+#include "bindings/core/v8/WrapperCreationSecurityCheck.h"
 #include "core/CoreExport.h"
 #include "platform/wtf/Compiler.h"
 #include "platform/wtf/text/AtomicString.h"
 #include "v8/include/v8.h"
 
 namespace blink {
 
 struct WrapperTypeInfo;
 
 class V8DOMWrapper {
@@ skipping 72 matching lines @@
   SECURITY_CHECK(ToScriptWrappable(wrapper) == impl);
   return wrapper;
 }
 
 class V8WrapperInstantiationScope {
   STACK_ALLOCATED();
 
  public:
   V8WrapperInstantiationScope(v8::Local<v8::Object> creation_context,
                               v8::Isolate* isolate,
-                              bool with_security_check)
+                              const WrapperTypeInfo* type)
       : did_enter_context_(false),
         context_(isolate->GetCurrentContext()),
         try_catch_(isolate),
-        convert_exceptions_(false) {
+        type_(type),
+        access_check_failed_(false) {
     // creationContext should not be empty. Because if we have an
     // empty creationContext, we will end up creating
     // a new object in the context currently entered. This is wrong.
     CHECK(!creation_context.IsEmpty());
     v8::Local<v8::Context> context_for_wrapper =
         creation_context->CreationContext();
 
     // For performance, we enter the context only if the currently running
     // context is different from the context that we are about to enter.
     if (context_for_wrapper == context_)
       return;
-    if (with_security_check) {
-      SecurityCheck(isolate, context_for_wrapper);
-    } else {
-      convert_exceptions_ = true;
+
+    context_ = context_for_wrapper;
+
+    if (!WrapperCreationSecurityCheck::VerifyContextAccess(context_, type_)) {
+      DCHECK(try_catch_.HasCaught());
+      try_catch_.ReThrow();
+      access_check_failed_ = true;
+      return;
     }
-    context_ = v8::Local<v8::Context>::New(isolate, context_for_wrapper);
+
     did_enter_context_ = true;
     context_->Enter();
   }
 
   ~V8WrapperInstantiationScope() {
     if (!did_enter_context_) {
       try_catch_.ReThrow();
       return;
     }
     context_->Exit();
-    // Rethrow any cross-context exceptions as security error.
-    if (try_catch_.HasCaught()) {
-      if (convert_exceptions_) {
-        try_catch_.Reset();
-        ConvertException();
-      }
-      try_catch_.ReThrow();
-    }
+
+    if (access_check_failed_ || !try_catch_.HasCaught())
+      return;
+
+    // Any exception caught here is a cross context exception and it may not be
+    // safe to directly rethrow the exception in the current context (without
+    // converting it). rethrowCrossContextException converts the exception in
+    // such a scenario.
+    v8::Local<v8::Value> caught_exception = try_catch_.Exception();
+    try_catch_.Reset();
+    WrapperCreationSecurityCheck::RethrowCrossContextException(
+        context_, type_, caught_exception);
+    try_catch_.ReThrow();
   }
 
   v8::Local<v8::Context> GetContext() const { return context_; }
+  bool AccessCheckFailed() const { return access_check_failed_; }
 
  private:
-  void SecurityCheck(v8::Isolate*, v8::Local<v8::Context> context_for_wrapper);
-  void ConvertException();
-
   bool did_enter_context_;
   v8::Local<v8::Context> context_;
   v8::TryCatch try_catch_;
-  bool convert_exceptions_;
+  const WrapperTypeInfo* type_;
+  bool access_check_failed_;
 };
 
 }  // namespace blink
 
 #endif  // V8DOMWrapper_h