Revert of DevTools: require enabling CSS domain before running CSS.* commands.

third_party/WebKit/Source/core/inspector/InspectorCSSAgent.cpp

 /*
  * Copyright (C) 2010, 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
  *     notice, this list of conditions and the following disclaimer in the
@@ skipping 739 matching lines @@
   if (!state_->booleanProperty(CSSAgentState::kCssAgentEnabled, false)) {
     // We were disabled while fetching resources.
     return;
   }
 
   instrumenting_agents_->addInspectorCSSAgent(this);
   dom_agent_->SetDOMListener(this);
   HeapVector<Member<Document>> documents = dom_agent_->Documents();
   for (Document* document : documents)
     UpdateActiveStyleSheets(document);
-  was_enabled_ = true;
 }
 
 Response InspectorCSSAgent::disable() {
   Reset();
   dom_agent_->SetDOMListener(nullptr);
   instrumenting_agents_->removeInspectorCSSAgent(this);
   state_->setBoolean(CSSAgentState::kCssAgentEnabled, false);
-  was_enabled_ = false;
   resource_content_loader_->Cancel(resource_content_loader_client_id_);
   state_->setBoolean(CSSAgentState::kRuleRecordingEnabled, false);
   SetCoverageEnabled(false);
   return Response::OK();
 }
 
 void InspectorCSSAgent::DidCommitLoadForLocalFrame(LocalFrame* frame) {
   if (frame == inspected_frames_->Root())
     Reset();
 }
@@ skipping 131 matching lines @@
     int node_id,
     Maybe<protocol::CSS::CSSStyle>* inline_style,
     Maybe<protocol::CSS::CSSStyle>* attributes_style,
     Maybe<protocol::Array<protocol::CSS::RuleMatch>>* matched_css_rules,
     Maybe<protocol::Array<protocol::CSS::PseudoElementMatches>>*
         pseudo_id_matches,
     Maybe<protocol::Array<protocol::CSS::InheritedStyleEntry>>*
         inherited_entries,
     Maybe<protocol::Array<protocol::CSS::CSSKeyframesRule>>*
         css_keyframes_rules) {
-  Response response = AssertEnabled();
+  Element* element = nullptr;
+  Response response = dom_agent_->AssertElement(node_id, element);
   if (!response.isSuccess())
     return response;
 
-  Element* element = nullptr;
-  response = dom_agent_->AssertElement(node_id, element);
-  if (!response.isSuccess())
-    return response;
-
   Element* original_element = element;
   PseudoId element_pseudo_id = element->GetPseudoId();
   if (element_pseudo_id) {
     element = element->ParentOrShadowHostElement();
     if (!element)
       return Response::Error("Pseudo element has no parent");
   }
 
   Document* owner_document = element->ownerDocument();
   // A non-active document has no styles.
@@ skipping 152 matching lines @@
                                      .setKeyframes(std::move(keyframes))
                                      .build());
   }
   return css_keyframes_rules;
 }
 
 Response InspectorCSSAgent::getInlineStylesForNode(
     int node_id,
     Maybe<protocol::CSS::CSSStyle>* inline_style,
     Maybe<protocol::CSS::CSSStyle>* attributes_style) {
-  Response response = AssertEnabled();
-  if (!response.isSuccess())
-    return response;
   Element* element = nullptr;
-  response = dom_agent_->AssertElement(node_id, element);
+  Response response = dom_agent_->AssertElement(node_id, element);
   if (!response.isSuccess())
     return response;
 
   InspectorStyleSheetForInlineStyle* style_sheet =
       AsInspectorStyleSheet(element);
   if (!style_sheet)
     return Response::Error("Element is not a style sheet");
 
   *inline_style = style_sheet->BuildObjectForStyle(element->style());
   *attributes_style = BuildObjectForAttributesStyle(element);
   return Response::OK();
 }
 
 Response InspectorCSSAgent::getComputedStyleForNode(
     int node_id,
     std::unique_ptr<protocol::Array<protocol::CSS::CSSComputedStyleProperty>>*
         style) {
-  Response response = AssertEnabled();
-  if (!response.isSuccess())
-    return response;
   Node* node = nullptr;
-  response = dom_agent_->AssertNode(node_id, node);
+  Response response = dom_agent_->AssertNode(node_id, node);
   if (!response.isSuccess())
     return response;
 
   CSSComputedStyleDeclaration* computed_style_info =
       CSSComputedStyleDeclaration::Create(node, true);
   *style = protocol::Array<protocol::CSS::CSSComputedStyleProperty>::create();
   for (int id = firstCSSProperty; id <= lastCSSProperty; ++id) {
     CSSPropertyID property_id = static_cast<CSSPropertyID>(id);
     if (!CSSPropertyMetadata::IsEnabledProperty(property_id) ||
         isShorthandProperty(property_id) ||
@@ skipping 45 matching lines @@
           std::make_pair(simple_font_data->IsCustomFont() ? 1 : 0, family_name),
           run_font_data.glyph_count_);
     }
   }
 }
 
 Response InspectorCSSAgent::getPlatformFontsForNode(
     int node_id,
     std::unique_ptr<protocol::Array<protocol::CSS::PlatformFontUsage>>*
         platform_fonts) {
-  Response response = AssertEnabled();
-  if (!response.isSuccess())
-    return response;
   Node* node = nullptr;
-  response = dom_agent_->AssertNode(node_id, node);
+  Response response = dom_agent_->AssertNode(node_id, node);
   if (!response.isSuccess())
     return response;
 
   HashCountedSet<std::pair<int, String>> font_stats;
   LayoutObject* root = node->GetLayoutObject();
   if (root) {
     CollectPlatformFontsForLayoutObject(root, &font_stats);
     // Iterate upto two layers deep.
     for (LayoutObject* child = root->SlowFirstChild(); child;
          child = child->NextSibling()) {
@@ skipping 365 matching lines @@
     return InspectorDOMAgent::ToResponse(exception_state);
 
   CSSStyleRule* rule = action->TakeRule();
   *result = BuildObjectForRule(rule);
   return Response::OK();
 }
 
 Response InspectorCSSAgent::forcePseudoState(
     int node_id,
     std::unique_ptr<protocol::Array<String>> forced_pseudo_classes) {
-  Response response = AssertEnabled();
-  if (!response.isSuccess())
-    return response;
   Element* element = nullptr;
-  response = dom_agent_->AssertElement(node_id, element);
+  Response response = dom_agent_->AssertElement(node_id, element);
   if (!response.isSuccess())
     return response;
 
   unsigned forced_pseudo_state =
       ComputePseudoClassMask(std::move(forced_pseudo_classes));
   NodeIdToForcedPseudoState::iterator it =
       node_id_to_forced_pseudo_state_.find(node_id);
   unsigned current_forced_pseudo_state =
       it == node_id_to_forced_pseudo_state_.end() ? 0 : it->value;
   bool need_style_recalc = forced_pseudo_state != current_forced_pseudo_state;
@@ skipping 304 matching lines @@
     return nullptr;
 
   CSSStyleSheet& inspector_sheet =
       document->GetStyleEngine().EnsureInspectorStyleSheet();
 
   FlushPendingProtocolNotifications();
 
   return css_style_sheet_to_inspector_style_sheet_.at(&inspector_sheet);
 }
 
-Response InspectorCSSAgent::AssertEnabled() {
-  return was_enabled_ ? Response::OK()
-                      : Response::Error("CSS agent was not enabled");
-}
-
 Response InspectorCSSAgent::AssertInspectorStyleSheetForId(
     const String& style_sheet_id,
     InspectorStyleSheet*& result) {
-  Response response = AssertEnabled();
-  if (!response.isSuccess())
-    return response;
   IdToInspectorStyleSheet::iterator it =
       id_to_inspector_style_sheet_.find(style_sheet_id);
   if (it == id_to_inspector_style_sheet_.end())
     return Response::Error("No style sheet with given id found");
   result = it->value.Get();
   return Response::OK();
 }
 
 Response InspectorCSSAgent::AssertStyleSheetForId(
     const String& style_sheet_id,
@@ skipping 629 matching lines @@
   visitor->Trace(css_style_sheet_to_inspector_style_sheet_);
   visitor->Trace(document_to_css_style_sheets_);
   visitor->Trace(invalidated_documents_);
   visitor->Trace(node_to_inspector_style_sheet_);
   visitor->Trace(inspector_user_agent_style_sheet_);
   visitor->Trace(tracker_);
   InspectorBaseAgent::Trace(visitor);
 }
 
 }  // namespace blink