blob: 54a79fbd68cd211e8cec7ebf608c95fd775823c6 [file] [log] [blame]
// Copyright 2015 The Cobalt Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef COBALT_CSSOM_COMPOUND_SELECTOR_H_
#define COBALT_CSSOM_COMPOUND_SELECTOR_H_
#include <memory>
#include <string>
#include "base/basictypes.h"
#include "base/compiler_specific.h"
#include "cobalt/cssom/selector.h"
#include "cobalt/cssom/simple_selector.h"
#include "cobalt/cssom/specificity.h"
namespace cobalt {
namespace cssom {
class Combinator;
class PseudoElement;
class SelectorVisitor;
// A compound selector is a chain of simple selectors that are not separated by
// a combinator.
// https://www.w3.org/TR/selectors4/#compound
class CompoundSelector : public Selector {
public:
typedef std::vector<std::unique_ptr<SimpleSelector>> SimpleSelectors;
CompoundSelector();
~CompoundSelector() override;
bool operator<(const CompoundSelector& that) const;
// From Selector.
void Accept(SelectorVisitor* visitor) override;
CompoundSelector* AsCompoundSelector() override { return this; }
Specificity GetSpecificity() const override { return specificity_; }
// Rest of public methods.
void AppendSelector(std::unique_ptr<SimpleSelector> selector);
const SimpleSelectors& simple_selectors() const { return simple_selectors_; }
PseudoElement* pseudo_element() {
if (has_pseudo_element_) {
for (SimpleSelectors::iterator iter = simple_selectors_.begin();
iter != simple_selectors_.end(); ++iter) {
if ((*iter)->AsPseudoElement()) {
return (*iter)->AsPseudoElement();
}
}
}
return NULL;
}
Combinator* left_combinator() { return left_combinator_; }
void set_left_combinator(Combinator* combinator) {
left_combinator_ = combinator;
}
Combinator* right_combinator() { return right_combinator_.get(); }
void set_right_combinator(std::unique_ptr<Combinator> combinator);
bool requires_rule_matching_verification_visit() const {
return requires_rule_matching_verification_visit_;
}
private:
Combinator* left_combinator_;
std::unique_ptr<Combinator> right_combinator_;
SimpleSelectors simple_selectors_;
Specificity specificity_;
bool has_pseudo_element_;
// This flag tracks whether or not during rule matching, after the initial
// candidate gathering phase, the simple selectors require additional checks
// during the verification phase to determine a match; otherwise, the act of
// being gathered itself proves the match.
// There are two cases where the selectors require a visit:
// 1. There are multiple selectors. Gathering only tests against the first
// selector and the later selectors must also be verified to match.
// 2. The single selector's AlwaysRequiresRuleMatchingVerificationVisit() call
// returns true. This indicates that being gathered as a candidate is not
// sufficient to prove a match and that additional verification checks are
// required.
bool requires_rule_matching_verification_visit_;
DISALLOW_COPY_AND_ASSIGN(CompoundSelector);
};
} // namespace cssom
} // namespace cobalt
#endif // COBALT_CSSOM_COMPOUND_SELECTOR_H_