Robustify Internals entry points against detached uses.

third_party/WebKit/Source/core/testing/Internals.cpp

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  * Copyright (C) 2013 Apple 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:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 473 matching lines @@
     return treeScope1->comparePosition(*treeScope2);
 }
 
 void Internals::pauseAnimations(double pauseTime, ExceptionState& exceptionState)
 {
     if (pauseTime < 0) {
         exceptionState.throwDOMException(InvalidAccessError, ExceptionMessages::indexExceedsMinimumBound("pauseTime", pauseTime, 0.0));
         return;
     }
 
+    if (!frame())
+        return;
+
     frame()->view()->updateAllLifecyclePhases();
     frame()->document()->timeline().pauseAnimationsForTesting(pauseTime);
 }
 
 bool Internals::isCompositedAnimation(Animation* animation)
 {
     return animation->hasActiveAnimationsOnCompositor();
 }
 
 void Internals::disableCompositedAnimation(Animation* animation)
@@ skipping 268 matching lines @@
     return document->autofocusElement();
 }
 
 bool Internals::hasAutofocusRequest()
 {
     return hasAutofocusRequest(0);
 }
 
 Vector<String> Internals::formControlStateOfHistoryItem(ExceptionState& exceptionState)
 {
-    HistoryItem* mainItem = frame()->loader().currentItem();
+    HistoryItem* mainItem = nullptr;
+    if (frame())
+        mainItem = frame()->loader().currentItem();
     if (!mainItem) {
         exceptionState.throwDOMException(InvalidAccessError, "No history item is available.");
         return Vector<String>();
     }
     return mainItem->documentState();
 }
 
 void Internals::setFormControlStateOfHistoryItem(const Vector<String>& state, ExceptionState& exceptionState)
 {
-    HistoryItem* mainItem = frame()->loader().currentItem();
+    HistoryItem* mainItem = nullptr;
+    if (frame())
+        mainItem = frame()->loader().currentItem();
     if (!mainItem) {
         exceptionState.throwDOMException(InvalidAccessError, "No history item is available.");
         return;
     }
     mainItem->clearDocumentState();
     mainItem->setDocumentState(state);
 }
 
 DOMWindow* Internals::pagePopupWindow() const
 {
@@ skipping 1063 matching lines @@
         exceptionState.throwDOMException(InvalidAccessError, document ? "The document's page cannot be retrieved." : "No context document can be obtained.");
         return;
     }
 
     Page* page = document->page();
     page->frameHost().setDefaultPageScaleLimits(minScaleFactor, maxScaleFactor);
 }
 
 bool Internals::magnifyScaleAroundAnchor(float scaleFactor, float x, float y)
 {
+    if (!frame())
+        return false;
+
     return frame()->host()->visualViewport().magnifyScaleAroundAnchor(scaleFactor, FloatPoint(x, y));
 }
 
 void Internals::setIsCursorVisible(Document* document, bool isVisible, ExceptionState& exceptionState)
 {
     ASSERT(document);
     if (!document->page()) {
         exceptionState.throwDOMException(InvalidAccessError, "No context document can be obtained.");
         return;
     }
@@ skipping 56 matching lines @@
     SchemeRegistry::removeURLSchemeRegisteredAsBypassingContentSecurityPolicy(scheme);
 }
 
 TypeConversions* Internals::typeConversions() const
 {
     return TypeConversions::create();
 }
 
 PrivateScriptTest* Internals::privateScriptTest() const
 {
+    if (!frame())
+        return nullptr;
+
     return PrivateScriptTest::create(frame()->document());
 }
 
 DictionaryTest* Internals::dictionaryTest() const
 {
     return DictionaryTest::create();
 }
 
 UnionTypesTest* Internals::unionTypesTest() const
 {
     return UnionTypesTest::create();
 }
 
 Vector<String> Internals::getReferencedFilePaths() const
 {
+    if (!frame())
+        return Vector<String>();
+
     return frame()->loader().currentItem()->getReferencedFilePaths();
 }
 
 void Internals::startTrackingRepaints(Document* document, ExceptionState& exceptionState)
 {
     ASSERT(document);
     if (!document->view()) {
         exceptionState.throwDOMException(InvalidAccessError, "The document provided is invalid.");
         return;
     }
@@ skipping 123 matching lines @@
     case Cursor::Grabbing: return "Grabbing";
     case Cursor::Custom: return "Custom";
     }
 
     ASSERT_NOT_REACHED();
     return "UNKNOWN";
 }
 
 String Internals::getCurrentCursorInfo()
 {
+    if (!frame())
+        return String();
+
     Cursor cursor = frame()->page()->chromeClient().lastSetCursorForTesting();
 
     StringBuilder result;
     result.append("type=");
     result.append(cursorTypeToString(cursor.getType()));
     result.append(" hotSpot=");
     result.appendNumber(cursor.hotSpot().x());
     result.append(',');
     result.appendNumber(cursor.hotSpot().y());
     if (cursor.getImage()) {
         IntSize size = cursor.getImage()->size();
         result.append(" image=");
         result.appendNumber(size.width());
         result.append('x');
         result.appendNumber(size.height());
     }
     if (cursor.imageScaleFactor() != 1) {
         result.append(" scale=");
         NumberToStringBuffer buffer;
         result.append(numberToFixedPrecisionString(cursor.imageScaleFactor(), 8, buffer, true));
     }
 
     return result.toString();
 }
 
 bool Internals::cursorUpdatePending() const
 {
+    if (!frame())
+        return false;
+
     return frame()->eventHandler().cursorUpdatePending();
 }
 
 DOMArrayBuffer* Internals::serializeObject(PassRefPtr<SerializedScriptValue> value) const
 {
     String stringValue = value->toWireString();
     DOMArrayBuffer* buffer = DOMArrayBuffer::createUninitialized(stringValue.length(), sizeof(UChar));
     stringValue.copyTo(static_cast<UChar*>(buffer->data()), 0, stringValue.length());
     return buffer;
 }
 
 PassRefPtr<SerializedScriptValue> Internals::deserializeBuffer(DOMArrayBuffer* buffer) const
 {
     String value(static_cast<const UChar*>(buffer->data()), buffer->byteLength() / sizeof(UChar));
     return SerializedScriptValue::create(value);
 }
 
 void Internals::forceReload(bool bypassCache)
 {
+    if (!frame())
+        return;
+
     frame()->reload(bypassCache ? FrameLoadTypeReloadBypassingCache : FrameLoadTypeReload, ClientRedirectPolicy::NotClientRedirect);
 }
 
 ClientRect* Internals::selectionBounds(ExceptionState& exceptionState)
 {
     Document* document = contextDocument();
     if (!document || !document->frame()) {
         exceptionState.throwDOMException(InvalidAccessError, document ? "The document's frame cannot be retrieved." : "No context document can be obtained.");
         return nullptr;
     }
@@ skipping 82 matching lines @@
     if (document->layoutViewItem().isNull()) {
         exceptionState.throwDOMException(InvalidAccessError, "The document provided is invalid.");
         return;
     }
 
     document->frame()->view()->updateAllLifecyclePhases();
 }
 
 void Internals::setZoomFactor(float factor)
 {
+    if (!frame())
+        return;
+
     frame()->setPageZoomFactor(factor);
 }
 
 void Internals::setShouldRevealPassword(Element* element, bool reveal, ExceptionState& exceptionState)
 {
     ASSERT(element);
     if (!isHTMLInputElement(element)) {
         exceptionState.throwDOMException(InvalidNodeTypeError, "The element provided is not an INPUT.");
         return;
     }
@@ skipping 97 matching lines @@
 {
     if (!node || !node->layoutObject())
         return String();
     blink::WebPoint point(x, y);
     SurroundingText surroundingText(createVisiblePosition(node->layoutObject()->positionForPoint(static_cast<IntPoint>(point))).deepEquivalent().parentAnchoredEquivalent(), maxLength);
     return surroundingText.content();
 }
 
 void Internals::setFocused(bool focused)
 {
+    if (!frame())
+        return;
+
     frame()->page()->focusController().setFocused(focused);
 }
 
 void Internals::setInitialFocus(bool reverse)
 {
+    if (!frame())
+        return;
+
     frame()->document()->clearFocusedElement();
     frame()->page()->focusController().setInitialFocus(reverse ? WebFocusTypeBackward : WebFocusTypeForward);
 }
 
 bool Internals::ignoreLayoutWithPendingStylesheets(Document* document)
 {
     ASSERT(document);
     return document->ignoreLayoutWithPendingStylesheets();
 }
 
@@ skipping 56 matching lines @@
     scrollState->setScrollChain(scrollChain);
 }
 
 void Internals::forceBlinkGCWithoutV8GC()
 {
     ThreadState::current()->setGCState(ThreadState::FullGCScheduled);
 }
 
 String Internals::selectedHTMLForClipboard()
 {
+    if (!frame())
+        return String();
+
     return frame()->selection().selectedHTMLForClipboard();
 }
 
 String Internals::selectedTextForClipboard()
 {
+    if (!frame())
+        return String();
+
     return frame()->selection().selectedTextForClipboard();
 }
 
 void Internals::setVisualViewportOffset(int x, int y)
 {
+    if (!frame())
+        return;
+
     frame()->host()->visualViewport().setLocation(FloatPoint(x, y));
 }
 
 int Internals::visualViewportHeight()
 {
+    if (!frame())
+        return 0;
+
     return expandedIntSize(frame()->host()->visualViewport().visibleRect().size()).height();
 }
 
 int Internals::visualViewportWidth()
 {
+    if (!frame())
+        return 0;
+
     return expandedIntSize(frame()->host()->visualViewport().visibleRect().size()).width();
 }
 
 double Internals::visualViewportScrollX()
 {
+    if (!frame())
+        return 0;
+
     return frame()->view()->getScrollableArea()->scrollPositionDouble().x();
 }
 
 double Internals::visualViewportScrollY()
 {
+    if (!frame())
+        return 0;
+
     return frame()->view()->getScrollableArea()->scrollPositionDouble().y();
 }
 
 ValueIterable<int>::IterationSource* Internals::startIteration(ScriptState*, ExceptionState&)
 {
     return new InternalsIterationSource();
 }
 
 bool Internals::isUseCounted(Document* document, int useCounterId)
 {
@@ skipping 79 matching lines @@
 }
 
 String Internals::getProgrammaticScrollAnimationState(Node* node) const
 {
     if (ScrollableArea* scrollableArea = scrollableAreaForNode(node))
         return scrollableArea->programmaticScrollAnimator().runStateAsText();
     return String();
 }
 
 } // namespace blink