Devirtualize ExceptionState's helper throwing methods.

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

 /*
  * 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 86 matching lines @@
 #endif  // DCHECK_IS_ON()
   }
 
   ~ExceptionState() {
     if (!m_exception.isEmpty()) {
       V8ThrowException::throwException(m_isolate,
                                        m_exception.newLocal(m_isolate));
     }
   }
 
+  virtual bool shouldThrow() const;
+
+  // const char* versions to avoid code bloat from inlined temporary Strings.
   void throwDOMException(ExceptionCode, const char* message);
   void throwRangeError(const char* message);
   void throwSecurityError(const char* sanitizedMessage,
                           const char* unsanitizedMessage = nullptr);
   void throwTypeError(const char* message);
 
-  virtual void throwDOMException(ExceptionCode, const String& message);
-  virtual void throwRangeError(const String& message);
-  virtual void throwSecurityError(const String& sanitizedMessage,
-                                  const String& unsanitizedMessage = String());
-  virtual void throwTypeError(const String& message);
-  virtual void rethrowV8Exception(v8::Local<v8::Value>);
+  void throwDOMException(ExceptionCode, const String& message);
+  void throwRangeError(const String& message);
+  void throwSecurityError(const String& sanitizedMessage,
+                          const String& unsanitizedMessage = String());
+  void throwTypeError(const String& message);
+
+  void rethrowV8Exception(v8::Local<v8::Value>);
 
   bool hadException() const { return m_code; }
   void clearException();
 
   ExceptionCode code() const { return m_code; }
   const String& message() const { return m_message; }
   v8::Local<v8::Value> getException() {
     DCHECK(!m_exception.isEmpty());
     return m_exception.newLocal(m_isolate);
   }
@@ skipping 10 matching lines @@
 
   String addExceptionContext(const String&) const;
 
  protected:
   // An ExceptionCode for the case that an exception is rethrown.  In that
   // case, we cannot determine an exception code.
   static const int kRethrownException = UnknownError;
 
   void setException(ExceptionCode, const String&, v8::Local<v8::Value>);
 
- private:
   ExceptionCode m_code;
   ContextType m_context;
   String m_message;
   const char* m_propertyName;
   const char* m_interfaceName;
   // The exception is empty when it was thrown through
   // DummyExceptionStateForTesting.
   ScopedPersistent<v8::Value> m_exception;
   v8::Isolate* m_isolate;
 };
 
 // NonThrowableExceptionState never allow call sites to throw an exception.
 // Should be used if an exception must not be thrown.
 class CORE_EXPORT NonThrowableExceptionState final : public ExceptionState {
  public:
   NonThrowableExceptionState();
   NonThrowableExceptionState(const char*, int);
 
-  void throwDOMException(ExceptionCode, const String& message) override;
-  void throwTypeError(const String& message) override;
-  void throwSecurityError(const String& sanitizedMessage,
-                          const String& unsanitizedMessage) override;
-  void throwRangeError(const String& message) override;
-  void rethrowV8Exception(v8::Local<v8::Value>) override;
   ExceptionState& returnThis() { return *this; }
 
+  // ExceptionState overrides:
+  bool shouldThrow() const override;
+
  private:
   const char* m_file;
   const int m_line;
 };
 
 // Syntax sugar for NonThrowableExceptionState.
 // This can be used as a default value of an ExceptionState parameter like this:
 //
 //     Node* removeChild(Node*, ExceptionState& = ASSERT_NO_EXCEPTION);
 #if DCHECK_IS_ON()
 #define ASSERT_NO_EXCEPTION \
   (::blink::NonThrowableExceptionState(__FILE__, __LINE__).returnThis())
 #else
 #define ASSERT_NO_EXCEPTION \
   (::blink::DummyExceptionStateForTesting().returnThis())
 #endif
 
 // DummyExceptionStateForTesting ignores all thrown exceptions. You should not
 // use DummyExceptionStateForTesting in production code, where you need to
 // handle all exceptions properly. If you really need to ignore exceptions in
 // production code for some special reason, explicitly call clearException().
 class CORE_EXPORT DummyExceptionStateForTesting final : public ExceptionState {
  public:
   DummyExceptionStateForTesting()
       : ExceptionState(nullptr,
                        ExceptionState::UnknownContext,
                        nullptr,
                        nullptr) {}
-  ~DummyExceptionStateForTesting() {
-    // Prevent the base class throw an exception.
-    if (hadException()) {
-      clearException();
-    }
-  }
-  void throwDOMException(ExceptionCode, const String& message) override;
-  void throwTypeError(const String& message) override;
-  void throwSecurityError(const String& sanitizedMessage,
-                          const String& unsanitizedMessage) override;
-  void throwRangeError(const String& message) override;
-  void rethrowV8Exception(v8::Local<v8::Value>) override;
+  ~DummyExceptionStateForTesting() {}
+
   ExceptionState& returnThis() { return *this; }
+
+  // ExceptionState overrides:
+  bool shouldThrow() const override;
 };
 
 // Syntax sugar for DummyExceptionStateForTesting.
 // This can be used as a default value of an ExceptionState parameter like this:
 //
 //     Node* removeChild(Node*, ExceptionState& = IGNORE_EXCEPTION_FOR_TESTING);
 #define IGNORE_EXCEPTION_FOR_TESTING \
   (::blink::DummyExceptionStateForTesting().returnThis())
 
 }  // namespace blink
 
 #endif  // ExceptionState_h