Add DocumentMarker::MatchStatus enum for text match markers

third_party/WebKit/Source/core/editing/markers/DocumentMarker.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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 46 matching lines @@
 
 inline DocumentMarkerDescription* toDocumentMarkerDescription(
     DocumentMarkerDetails* details) {
   if (details && details->isDescription())
     return static_cast<DocumentMarkerDescription*>(details);
   return 0;
 }
 
 class DocumentMarkerTextMatch final : public DocumentMarkerDetails {
  public:
-  static DocumentMarkerTextMatch* create(bool);
+  static DocumentMarkerTextMatch* create(DocumentMarker::MatchStatus);
 
-  bool IsActiveMatch() const { return m_match; }
+  bool IsActiveMatch() const {
+    return m_matchStatus == DocumentMarker::MatchStatus::kActive;
+  }
 
   bool isTextMatch() const override { return true; }
 
  private:
-  explicit DocumentMarkerTextMatch(bool match) : m_match(match) {}
+  explicit DocumentMarkerTextMatch(DocumentMarker::MatchStatus matchStatus)
+      : m_matchStatus(matchStatus) {}
 
-  bool m_match;
+  DocumentMarker::MatchStatus m_matchStatus;
 };
 
-DocumentMarkerTextMatch* DocumentMarkerTextMatch::create(bool match) {
-  DEFINE_STATIC_LOCAL(DocumentMarkerTextMatch, trueInstance,
-                      (new DocumentMarkerTextMatch(true)));
-  DEFINE_STATIC_LOCAL(DocumentMarkerTextMatch, falseInstance,
-                      (new DocumentMarkerTextMatch(false)));
-  return match ? &trueInstance : &falseInstance;
+DocumentMarkerTextMatch* DocumentMarkerTextMatch::create(
+    DocumentMarker::MatchStatus matchStatus) {
+  DEFINE_STATIC_LOCAL(
+      DocumentMarkerTextMatch, activeInstance,
+      (new DocumentMarkerTextMatch(DocumentMarker::MatchStatus::kActive)));
+  DEFINE_STATIC_LOCAL(
+      DocumentMarkerTextMatch, inactiveInstance,
+      (new DocumentMarkerTextMatch(DocumentMarker::MatchStatus::kInactive)));
+  return matchStatus == DocumentMarker::MatchStatus::kActive
+             ? &activeInstance
+             : &inactiveInstance;
 }
 
 inline DocumentMarkerTextMatch* toDocumentMarkerTextMatch(
     DocumentMarkerDetails* details) {
   if (details && details->isTextMatch())
     return static_cast<DocumentMarkerTextMatch*>(details);
   return 0;
 }
 
 class TextCompositionMarkerDetails final : public DocumentMarkerDetails {
@@ skipping 41 matching lines @@
                                const String& description)
     : m_type(type),
       m_startOffset(startOffset),
       m_endOffset(endOffset),
       m_details(description.isEmpty()
                     ? nullptr
                     : DocumentMarkerDescription::create(description)) {}
 
 DocumentMarker::DocumentMarker(unsigned startOffset,
                                unsigned endOffset,
-                               bool activeMatch)
+                               DocumentMarker::MatchStatus matchStatus)
     : m_type(DocumentMarker::TextMatch),
       m_startOffset(startOffset),
       m_endOffset(endOffset),
-      m_details(DocumentMarkerTextMatch::create(activeMatch)) {}
+      m_details(DocumentMarkerTextMatch::create(matchStatus)) {}
 
 DocumentMarker::DocumentMarker(unsigned startOffset,
                                unsigned endOffset,
                                Color underlineColor,
                                bool thick,
                                Color backgroundColor)
     : m_type(DocumentMarker::Composition),
       m_startOffset(startOffset),
       m_endOffset(endOffset),
       m_details(TextCompositionMarkerDetails::create(underlineColor,
                                                      thick,
                                                      backgroundColor)) {}
 
 DocumentMarker::DocumentMarker(const DocumentMarker& marker)
     : m_type(marker.type()),
       m_startOffset(marker.startOffset()),
       m_endOffset(marker.endOffset()),
       m_details(marker.details()) {}
 
 void DocumentMarker::shiftOffsets(int delta) {
   m_startOffset += delta;
   m_endOffset += delta;
 }
 
 void DocumentMarker::setIsActiveMatch(bool active) {
-  m_details = DocumentMarkerTextMatch::create(active);
+  m_details = DocumentMarkerTextMatch::create(
+      active ? DocumentMarker::MatchStatus::kActive
+             : DocumentMarker::MatchStatus::kInactive);
 }
 
 const String& DocumentMarker::description() const {
   if (DocumentMarkerDescription* details =
           toDocumentMarkerDescription(m_details.get()))
     return details->description();
   return emptyString;
 }
 
 bool DocumentMarker::IsActiveMatch() const {
@@ skipping 22 matching lines @@
           toTextCompositionMarkerDetails(m_details.get()))
     return details->backgroundColor();
   return Color::transparent;
 }
 
 DEFINE_TRACE(DocumentMarker) {
   visitor->trace(m_details);
 }
 
 }  // namespace blink