[DevTools] Remove layout editor experiment.

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 21 matching lines @@
 #include "bindings/core/v8/ScriptSourceCode.h"
 #include "bindings/core/v8/V8InspectorOverlayHost.h"
 #include "core/dom/Node.h"
 #include "core/dom/StaticNodeList.h"
 #include "core/frame/FrameHost.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/frame/VisualViewport.h"
 #include "core/input/EventHandler.h"
-#include "core/inspector/InspectorCSSAgent.h"
 #include "core/inspector/InspectorOverlayHost.h"
-#include "core/inspector/LayoutEditor.h"
 #include "core/layout/api/LayoutViewItem.h"
 #include "core/loader/EmptyClients.h"
 #include "core/loader/FrameLoadRequest.h"
 #include "core/page/ChromeClient.h"
 #include "core/page/Page.h"
 #include "platform/ScriptForbiddenScope.h"
 #include "platform/graphics/GraphicsContext.h"
 #include "platform/graphics/paint/CullRect.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebData.h"
@@ skipping 83 matching lines @@
   DEFINE_INLINE_VIRTUAL_TRACE() {
     visitor->trace(m_client);
     visitor->trace(m_overlay);
     EmptyChromeClient::trace(visitor);
   }
 
   void setCursor(const Cursor& cursor, LocalFrame* localRoot) override {
     toChromeClientImpl(m_client)->setCursorOverridden(false);
     toChromeClientImpl(m_client)->setCursor(cursor,
                                             m_overlay->m_frameImpl->frame());
-    bool overrideCursor = m_overlay->m_layoutEditor;
-    toChromeClientImpl(m_client)->setCursorOverridden(overrideCursor);
+    toChromeClientImpl(m_client)->setCursorOverridden(false);
   }
 
   void setToolTip(LocalFrame& frame,
                   const String& tooltip,
                   TextDirection direction) override {
     DCHECK_EQ(&frame, m_overlay->overlayMainFrame());
     m_client->setToolTip(*m_overlay->m_frameImpl->frame(), tooltip, direction);
   }
 
   void invalidateRect(const IntRect&) override { m_overlay->invalidate(); }
@@ skipping 31 matching lines @@
 }
 
 DEFINE_TRACE(InspectorOverlay) {
   visitor->trace(m_frameImpl);
   visitor->trace(m_highlightNode);
   visitor->trace(m_eventTargetNode);
   visitor->trace(m_overlayPage);
   visitor->trace(m_overlayChromeClient);
   visitor->trace(m_overlayHost);
   visitor->trace(m_domAgent);
-  visitor->trace(m_cssAgent);
-  visitor->trace(m_layoutEditor);
   visitor->trace(m_hoveredNodeForInspectMode);
 }
 
-void InspectorOverlay::init(InspectorCSSAgent* cssAgent,
-                            v8_inspector::V8InspectorSession* v8Session,
+void InspectorOverlay::init(v8_inspector::V8InspectorSession* v8Session,
                             InspectorDOMAgent* domAgent) {
   m_v8Session = v8Session;
   m_domAgent = domAgent;
-  m_cssAgent = cssAgent;
   m_overlayHost->setListener(this);
 }
 
 void InspectorOverlay::invalidate() {
   if (!m_pageOverlay) {
     m_pageOverlay = PageOverlay::create(
         m_frameImpl, wrapUnique(new InspectorPageOverlayDelegate(*this)));
   }
 
   m_pageOverlay->update();
@@ skipping 131 matching lines @@
   m_nodeHighlightConfig = highlightConfig;
   m_highlightNode = node;
   m_eventTargetNode = eventTarget;
   m_omitTooltip = omitTooltip;
   scheduleUpdate();
 }
 
 void InspectorOverlay::setInspectMode(
     InspectorDOMAgent::SearchMode searchMode,
     std::unique_ptr<InspectorHighlightConfig> highlightConfig) {
-  if (m_layoutEditor)
-    overlayClearSelection(true);
-
   m_inspectMode = searchMode;
   scheduleUpdate();
 
   if (searchMode != InspectorDOMAgent::NotSearching) {
     m_inspectModeHighlightConfig = std::move(highlightConfig);
   } else {
     m_hoveredNodeForInspectMode.clear();
     hideHighlight();
   }
 }
 
-void InspectorOverlay::setInspectedNode(Node* node) {
-  if (m_inspectMode != InspectorDOMAgent::ShowLayoutEditor ||
-      (m_layoutEditor && m_layoutEditor->element() == node))
-    return;
-
-  if (m_layoutEditor) {
-    m_layoutEditor->commitChanges();
-    m_layoutEditor.clear();
-  }
-  initializeLayoutEditorIfNeeded(node);
-}
-
 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() {
@@ skipping 38 matching lines @@
   reset(viewportSize, visibleRectInDocument.location());
 
   if (m_showReloadingBlanket) {
     evaluateInOverlay("showReloadingBlanket", "");
     return;
   }
   drawNodeHighlight();
   drawQuadHighlight();
   drawPausedInDebuggerMessage();
   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());
   return result;
 }
@@ skipping 213 matching lines @@
               ScriptController::ExecuteScriptWhenScriptsDisabled);
   return toCoreStringWithUndefinedOrNullCheck(string);
 }
 
 void InspectorOverlay::onTimer(TimerBase*) {
   m_resizeTimerActive = false;
   scheduleUpdate();
 }
 
 void InspectorOverlay::clearInternal() {
-  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_inspectMode = InspectorDOMAgent::NotSearching;
   m_timer.stop();
   hideHighlight();
 }
 
 void InspectorOverlay::clear() {
   clearInternal();
   m_v8Session = nullptr;
   m_domAgent.clear();
-  m_cssAgent.clear();
   m_overlayHost->setListener(nullptr);
 }
 
 void InspectorOverlay::overlayResumed() {
   if (m_v8Session)
     m_v8Session->resume();
 }
 
 void InspectorOverlay::overlaySteppedOver() {
   if (m_v8Session)
     m_v8Session->stepOver();
 }
 
-void InspectorOverlay::overlayStartedPropertyChange(const String& property) {
-  DCHECK(m_layoutEditor);
-  m_layoutEditor->overlayStartedPropertyChange(property);
-}
-
-void InspectorOverlay::overlayPropertyChanged(float value) {
-  DCHECK(m_layoutEditor);
-  m_layoutEditor->overlayPropertyChanged(value);
-}
-
-void InspectorOverlay::overlayEndedPropertyChange() {
-  DCHECK(m_layoutEditor);
-  m_layoutEditor->overlayEndedPropertyChange();
-}
-
-void InspectorOverlay::overlayNextSelector() {
-  DCHECK(m_layoutEditor);
-  m_layoutEditor->nextSelector();
-}
-
-void InspectorOverlay::overlayPreviousSelector() {
-  DCHECK(m_layoutEditor);
-  m_layoutEditor->previousSelector();
-}
-
-void InspectorOverlay::overlayClearSelection(bool commitChanges) {
-  DCHECK(m_layoutEditor);
-  m_hoveredNodeForInspectMode = m_layoutEditor->element();
-
-  if (commitChanges)
-    m_layoutEditor->commitChanges();
-
-  if (m_layoutEditor) {
-    m_layoutEditor->dispose();
-    m_layoutEditor.clear();
-  }
-
-  if (m_inspectModeHighlightConfig)
-    highlightNode(m_hoveredNodeForInspectMode.get(),
-                  *m_inspectModeHighlightConfig, false);
-
-  toChromeClientImpl(m_frameImpl->frame()->host()->chromeClient())
-      .setCursorOverridden(false);
-  toChromeClientImpl(m_frameImpl->frame()->host()->chromeClient())
-      .setCursor(pointerCursor(), overlayMainFrame());
-}
-
 void InspectorOverlay::suspend() {
   if (!m_suspended) {
     m_suspended = true;
     clearInternal();
   }
 }
 
 void InspectorOverlay::resume() {
   m_suspended = false;
 }
@@ skipping 78 matching lines @@
   Node* node = hoveredNodeForEvent(m_frameImpl->frame(), event, false);
   if (node && m_inspectModeHighlightConfig) {
     highlightNode(node, *m_inspectModeHighlightConfig, false);
     inspect(node);
     return true;
   }
   return false;
 }
 
 bool InspectorOverlay::shouldSearchForNode() {
-  return m_inspectMode != InspectorDOMAgent::NotSearching && !m_layoutEditor;
+  return m_inspectMode != InspectorDOMAgent::NotSearching;
 }
 
 void InspectorOverlay::inspect(Node* node) {
   if (m_domAgent)
     m_domAgent->inspect(node);
-
-  initializeLayoutEditorIfNeeded(node);
-  if (m_layoutEditor)
-    hideHighlight();
-}
-
-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_frameImpl->frame()->host()->chromeClient())
-      .setCursorOverridden(true);
 }
 
 }  // namespace blink