Timeline: show white overlay till page being reloaded paints

third_party/WebKit/Source/web/InspectorOverlay.cpp

 /*
  * Copyright (C) 2011 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:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 155 matching lines @@
         , m_overlay(&overlay)
     { }
 
     Member<ChromeClient> m_client;
     Member<InspectorOverlay> m_overlay;
 };
 
 
 InspectorOverlay::InspectorOverlay(WebViewImpl* webViewImpl)
     : m_webViewImpl(webViewImpl)
+    , m_messageType(MessageType::Empty)
     , m_overlayHost(InspectorOverlayHost::create())
     , m_drawViewSize(false)
     , m_resizeTimerActive(false)
     , m_omitTooltip(false)
     , m_timer(this, &InspectorOverlay::onTimer)
     , m_suspended(false)
     , m_inLayout(false)
     , m_needsUpdate(false)
     , m_inspectMode(InspectorDOMAgent::NotSearching)
 {
@@ skipping 97 matching lines @@
     if (inputEvent.type == WebInputEvent::MouseWheel) {
         PlatformWheelEvent wheelEvent = PlatformWheelEventBuilder(m_webViewImpl->mainFrameImpl()->frameView(), static_cast<const WebMouseWheelEvent&>(inputEvent));
         handled = overlayMainFrame()->eventHandler().handleWheelEvent(wheelEvent) != WebInputEventResult::NotHandled;
     }
 
     return handled;
 }
 
 void InspectorOverlay::setPausedInDebuggerMessage(const String& message)
 {
-    m_pausedInDebuggerMessage = message;
+    m_message = message;
+    m_messageType = message.isNull() ? MessageType::Empty : MessageType::PausedInDebugger;
     scheduleUpdate();
 }
 
+void InspectorOverlay::setReloadingBanner(const String& message)
+{
+    DCHECK(!message.isNull());
+    m_message = message;
+    m_messageType = MessageType::Reloading;
+    scheduleUpdate();
+}
+
+void InspectorOverlay::maybeClearReloadingBanner()
+{
+    if (m_messageType != MessageType::Reloading)
+        return;
+    m_message = String();
+    m_messageType = MessageType::Empty;
+    if (m_suspended)
+        clearInternal();
+    else
+        scheduleUpdate();
+}
+
 void InspectorOverlay::hideHighlight()
 {
     m_highlightNode.clear();
     m_eventTargetNode.clear();
     m_highlightQuad.reset();
     scheduleUpdate();
 }
 
 void InspectorOverlay::highlightNode(Node* node, const InspectorHighlightConfig& highlightConfig, bool omitTooltip)
 {
@@ skipping 40 matching lines @@
 void InspectorOverlay::highlightQuad(std::unique_ptr<FloatQuad> quad, const InspectorHighlightConfig& highlightConfig)
 {
     m_quadHighlightConfig = highlightConfig;
     m_highlightQuad = std::move(quad);
     m_omitTooltip = false;
     scheduleUpdate();
 }
 
 bool InspectorOverlay::isEmpty()
 {
-    if (m_suspended)
+    if (m_suspended && m_messageType != MessageType::Reloading)
         return true;
-    bool hasVisibleElements = m_highlightNode || m_eventTargetNode || m_highlightQuad  || (m_resizeTimerActive && m_drawViewSize) || !m_pausedInDebuggerMessage.isNull();
+    bool hasVisibleElements = m_highlightNode || m_eventTargetNode || m_highlightQuad  || (m_resizeTimerActive && m_drawViewSize) || !m_message.isNull();
     return !hasVisibleElements && m_inspectMode == InspectorDOMAgent::NotSearching;
 }
 
 void InspectorOverlay::scheduleUpdate()
 {
     if (isEmpty()) {
         if (m_pageOverlay)
             m_pageOverlay.reset();
         return;
     }
@@ skipping 13 matching lines @@
     IntSize viewportSize = m_webViewImpl->page()->frameHost().visualViewport().size();
     LocalFrame* frame = toLocalFrame(overlayPage()->mainFrame());
     frame->view()->resize(viewportSize);
     overlayPage()->frameHost().visualViewport().setSize(viewportSize);
     frame->setPageZoomFactor(windowToViewportScale());
 
     reset(viewportSize, visibleRectInDocument.location());
 
     drawNodeHighlight();
     drawQuadHighlight();
-    drawPausedInDebuggerMessage();
+    drawMessages();
     drawViewSize();
     if (m_layoutEditor && !m_highlightNode)
         m_layoutEditor->rebuild();
 }
 
 static std::unique_ptr<protocol::DictionaryValue> buildObjectForSize(const IntSize& size)
 {
     std::unique_ptr<protocol::DictionaryValue> result = protocol::DictionaryValue::create();
     result->setInteger("width", size.width());
     result->setInteger("height", size.height());
@@ skipping 34 matching lines @@
 void InspectorOverlay::drawQuadHighlight()
 {
     if (!m_highlightQuad)
         return;
 
     InspectorHighlight highlight(windowToViewportScale());
     highlight.appendQuad(*m_highlightQuad, m_quadHighlightConfig.content, m_quadHighlightConfig.contentOutline);
     evaluateInOverlay("drawHighlight", highlight.asProtocolValue());
 }
 
-void InspectorOverlay::drawPausedInDebuggerMessage()
+void InspectorOverlay::drawMessages()
 {
-    if (m_inspectMode == InspectorDOMAgent::NotSearching && !m_pausedInDebuggerMessage.isNull())
-        evaluateInOverlay("drawPausedInDebuggerMessage", m_pausedInDebuggerMessage);
+    if (!m_suspended && m_inspectMode == InspectorDOMAgent::NotSearching && m_messageType == MessageType::PausedInDebugger)
+        evaluateInOverlay("drawPausedInDebuggerMessage", m_message);
+    else if (m_messageType == MessageType::Reloading)
+        evaluateInOverlay("drawReloadingMessage", m_message);
 }
 
 void InspectorOverlay::drawViewSize()
 {
     if (m_resizeTimerActive && m_drawViewSize)
         evaluateInOverlay("drawViewSize", "");
 }
 
 float InspectorOverlay::windowToViewportScale() const
 {
@@ skipping 124 matching lines @@
 {
     if (m_layoutEditor)
         m_layoutEditor.clear();
 
     if (m_overlayPage) {
         m_overlayPage->willBeDestroyed();
         m_overlayPage.clear();
         m_overlayChromeClient.clear();
     }
     m_resizeTimerActive = false;
-    m_pausedInDebuggerMessage = String();
+    m_message = String();
     m_inspectMode = InspectorDOMAgent::NotSearching;
     m_timer.stop();
     hideHighlight();
 }
 
 void InspectorOverlay::clear()
 {
     clearInternal();
     m_v8Session = nullptr;
     m_domAgent.clear();
@@ skipping 58 matching lines @@
 
     if (m_inspectModeHighlightConfig)
         highlightNode(m_hoveredNodeForInspectMode.get(), *m_inspectModeHighlightConfig, false);
 
     toChromeClientImpl(m_webViewImpl->page()->chromeClient()).setCursorOverridden(false);
     toChromeClientImpl(m_webViewImpl->page()->chromeClient()).setCursor(pointerCursor(), overlayMainFrame());
 }
 
 void InspectorOverlay::suspend()
 {
-    if (!m_suspended) {
-        m_suspended = true;
-        clearInternal();
-    }
+    if (m_suspended)
+        return;
+    m_suspended = true;
+    clearInternal();
 }
 
 void InspectorOverlay::resume()
 {
     m_suspended = false;
 }
 
 void InspectorOverlay::pageLayoutInvalidated(bool resized)
 {
     if (resized && m_drawViewSize) {
@@ skipping 101 matching lines @@
 
 void InspectorOverlay::initializeLayoutEditorIfNeeded(Node* node)
 {
     if (m_inspectMode != InspectorDOMAgent::ShowLayoutEditor || !node || !node->isElementNode() || !node->ownerDocument()->isActive() || !m_cssAgent || !m_domAgent)
         return;
     m_layoutEditor = LayoutEditor::create(toElement(node), m_cssAgent, m_domAgent, &overlayMainFrame()->script());
     toChromeClientImpl(m_webViewImpl->page()->chromeClient()).setCursorOverridden(true);
 }
 
 } // namespace blink