Move CreateDOMException out of V8ThrowException

third_party/WebKit/Source/bindings/core/v8/ExceptionState.cpp

 /*
  * Copyright (C) 2013 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 14 matching lines @@
  * 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.
  */
 
 #include "bindings/core/v8/ExceptionState.h"
 
 #include "bindings/core/v8/ExceptionMessages.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
-#include "bindings/core/v8/V8ThrowException.h"
-#include "core/dom/ExceptionCode.h"
+#include "bindings/core/v8/V8ThrowDOMException.h"
 
 namespace blink {
 
 void ExceptionState::ThrowDOMException(ExceptionCode ec, const char* message) {
   ThrowDOMException(ec, String(message));
 }
 
 void ExceptionState::ThrowRangeError(const char* message) {
   ThrowRangeError(String(message));
 }
@@ skipping 10 matching lines @@
 void ExceptionState::ThrowDOMException(ExceptionCode ec,
                                        const String& message) {
   // SecurityError is thrown via ::throwSecurityError, and _careful_
   // consideration must be given to the data exposed to JavaScript via the
   // 'sanitizedMessage'.
   DCHECK(ec != kSecurityError);
 
   const String& processed_message = AddExceptionContext(message);
   SetException(
       ec, processed_message,
-      V8ThrowException::CreateDOMException(isolate_, ec, processed_message));
+      V8ThrowDOMException::CreateDOMException(isolate_, ec, processed_message));
 }
 
 void ExceptionState::ThrowRangeError(const String& message) {
   SetException(kV8RangeError, message,
                V8ThrowException::CreateRangeError(
                    isolate_, AddExceptionContext(message)));
 }
 
 void ExceptionState::ThrowSecurityError(const String& sanitized_message,
                                         const String& unsanitized_message) {
   const String& final_sanitized = AddExceptionContext(sanitized_message);
   const String& final_unsanitized = AddExceptionContext(unsanitized_message);
   SetException(
       kSecurityError, final_sanitized,
-      V8ThrowException::CreateDOMException(isolate_, kSecurityError,
-                                           final_sanitized, final_unsanitized));
+      V8ThrowDOMException::CreateDOMException(
+          isolate_, kSecurityError, final_sanitized, final_unsanitized));
 }
 
 void ExceptionState::ThrowTypeError(const String& message) {
   SetException(kV8TypeError, message,
                V8ThrowException::CreateTypeError(isolate_,
                                                  AddExceptionContext(message)));
 }
 
 void ExceptionState::RethrowV8Exception(v8::Local<v8::Value> value) {
   SetException(kRethrownException, String(), value);
@@ skipping 126 matching lines @@
 
 void DummyExceptionStateForTesting::ThrowTypeError(const String& message) {
   SetException(kV8TypeError, message, v8::Local<v8::Value>());
 }
 
 void DummyExceptionStateForTesting::RethrowV8Exception(v8::Local<v8::Value>) {
   SetException(kRethrownException, String(), v8::Local<v8::Value>());
 }
 
 }  // namespace blink