Rename {Author,UserAgent}ShadowRoot to {Open,Closed}ShadowRoot.

Source/core/inspector/InspectorDOMAgent.cpp

 /*
  * Copyright (C) 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2011 Google Inc. All rights reserved.
  * Copyright (C) 2009 Joseph Pecoraro
  *
  * 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
@@ skipping 440 matching lines @@
     if (!node)
         return nullptr;
 
     if (!node->isElementNode()) {
         *errorString = "Node is not an Element";
         return nullptr;
     }
     return toElement(node);
 }
 
-static ShadowRoot* userAgentShadowRoot(Node* node)
+static ShadowRoot* closedShadowRoot(Node* node)
 {
     if (!node || !node->isInShadowTree())
         return nullptr;
 
     Node* candidate = node;
     while (candidate && !candidate->isShadowRoot())
         candidate = candidate->parentOrShadowHostNode();
     ASSERT(candidate);
     ShadowRoot* shadowRoot = toShadowRoot(candidate);
 
-    return shadowRoot->type() == ShadowRoot::UserAgentShadowRoot ? shadowRoot : nullptr;
+    return shadowRoot->type() == ShadowRoot::ClosedShadowRoot ? shadowRoot : nullptr;
 }
 
 Node* InspectorDOMAgent::assertEditableNode(ErrorString* errorString, int nodeId)
 {
     Node* node = assertNode(errorString, nodeId);
     if (!node)
         return nullptr;
 
     if (node->isInShadowTree()) {
         if (node->isShadowRoot()) {
             *errorString = "Cannot edit shadow roots";
             return nullptr;
         }
-        if (userAgentShadowRoot(node)) {
+        if (closedShadowRoot(node)) {
             *errorString = "Cannot edit nodes from user-agent shadow trees";
             return nullptr;
         }
     }
 
     if (node->isPseudoElement()) {
         *errorString = "Cannot edit pseudo elements";
         return nullptr;
     }
 
@@ skipping 11 matching lines @@
     }
     return node;
 }
 
 Element* InspectorDOMAgent::assertEditableElement(ErrorString* errorString, int nodeId)
 {
     Element* element = assertElement(errorString, nodeId);
     if (!element)
         return nullptr;
 
-    if (element->isInShadowTree() && userAgentShadowRoot(element)) {
+    if (element->isInShadowTree() && closedShadowRoot(element)) {
         *errorString = "Cannot edit elements from user-agent shadow trees";
         return nullptr;
     }
 
     if (element->isPseudoElement()) {
         *errorString = "Cannot edit pseudo elements";
         return nullptr;
     }
 
     return element;
@@ skipping 521 matching lines @@
 
 static Node* nextNodeWithShadowDOMInMind(const Node& current, const Node* stayWithin, bool includeUserAgentShadowDOM)
 {
     // At first traverse the subtree.
     if (current.isElementNode()) {
         const Element& element = toElement(current);
         ElementShadow* elementShadow = element.shadow();
         if (elementShadow) {
             ShadowRoot* shadowRoot = elementShadow->youngestShadowRoot();
             if (shadowRoot) {
-                if (shadowRoot->type() == ShadowRoot::AuthorShadowRoot || includeUserAgentShadowDOM)
+                if (shadowRoot->type() == ShadowRoot::OpenShadowRoot || includeUserAgentShadowDOM)
                     return shadowRoot;
             }
         }
     }
     if (current.hasChildren())
         return current.firstChild();
 
     // Then traverse siblings of the node itself and its ancestors.
     const Node* node = &current;
     do {
@@ skipping 217 matching lines @@
 
 bool InspectorDOMAgent::handleMouseMove(LocalFrame* frame, const PlatformMouseEvent& event)
 {
     if (m_searchingForNode == NotSearching)
         return false;
 
     if (!frame->view() || !frame->contentRenderer())
         return true;
     Node* node = hoveredNodeForEvent(frame, event, event.shiftKey());
 
-    // Do not highlight within UA shadow root unless requested.
+    // Do not highlight within closed shadow root unless requested.
     if (m_searchingForNode != SearchingForUAShadow) {
-        ShadowRoot* uaShadowRoot = userAgentShadowRoot(node);
-        if (uaShadowRoot)
-            node = uaShadowRoot->host();
+        ShadowRoot* shadowRoot = closedShadowRoot(node);
+        if (shadowRoot)
+            node = shadowRoot->host();
     }
 
     // Shadow roots don't have boxes - use host element instead.
     if (node && node->isShadowRoot())
         node = node->parentOrShadowHostNode();
 
     if (!node)
         return true;
 
     Node* eventTarget = event.shiftKey() ? hoveredNodeForEvent(frame, event, false) : nullptr;
@@ skipping 315 matching lines @@
 }
 
 static String documentBaseURLString(Document* document)
 {
     return document->completeURL("").string();
 }
 
 static TypeBuilder::DOM::ShadowRootType::Enum shadowRootType(ShadowRoot* shadowRoot)
 {
     switch (shadowRoot->type()) {
-    case ShadowRoot::UserAgentShadowRoot:
+    case ShadowRoot::ClosedShadowRoot:
         return TypeBuilder::DOM::ShadowRootType::User_agent;
-    case ShadowRoot::AuthorShadowRoot:
+    case ShadowRoot::OpenShadowRoot:
         return TypeBuilder::DOM::ShadowRootType::Author;
     }
     ASSERT_NOT_REACHED();
     return TypeBuilder::DOM::ShadowRootType::User_agent;
 }
 
 PassRefPtr<TypeBuilder::DOM::Node> InspectorDOMAgent::buildObjectForNode(Node* node, int depth, NodeToIdMap* nodesMap)
 {
     int id = bind(node, nodesMap);
     String localName;
@@ skipping 515 matching lines @@
     m_frontend->pseudoElementRemoved(parentId, pseudoElementId);
 }
 
 static ShadowRoot* shadowRootForNode(Node* node, const String& type)
 {
     if (!node->isElementNode())
         return nullptr;
     if (type == "a")
         return toElement(node)->shadowRoot();
     if (type == "u")
-        return toElement(node)->userAgentShadowRoot();
+        return toElement(node)->closedShadowRoot();
     return nullptr;
 }
 
 Node* InspectorDOMAgent::nodeForPath(const String& path)
 {
     // The path is of form "1,HTML,2,BODY,1,DIV" (<index> and <nodeName> interleaved).
     // <index> may also be "a" (author shadow root) or "u" (user-agent shadow root),
     // in which case <nodeName> MUST be "#document-fragment".
     if (!m_document)
         return nullptr;
@@ skipping 117 matching lines @@
     visitor->trace(m_revalidateTask);
     visitor->trace(m_searchResults);
 #endif
     visitor->trace(m_history);
     visitor->trace(m_domEditor);
     visitor->trace(m_listener);
     InspectorBaseAgent::trace(visitor);
 }
 
 } // namespace blink