Blink handle selection handle visibility

third_party/WebKit/Source/core/editing/VisibleSelection.cpp

 /*
  * Copyright (C) 2004, 2005, 2006 Apple Computer, 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 41 matching lines @@
 {
 }
 
 template <typename Strategy>
 VisibleSelectionTemplate<Strategy>::VisibleSelectionTemplate(const PositionTemplate<Strategy>& pos, TextAffinity affinity, bool isDirectional)
     : VisibleSelectionTemplate(pos, pos, affinity, isDirectional)
 {
 }
 
 template <typename Strategy>
-VisibleSelectionTemplate<Strategy>::VisibleSelectionTemplate(const PositionTemplate<Strategy>& base, const PositionTemplate<Strategy>& extent, TextAffinity affinity, bool isDirectional)
+VisibleSelectionTemplate<Strategy>::VisibleSelectionTemplate(const PositionTemplate<Strategy>& base, const PositionTemplate<Strategy>& extent, TextAffinity affinity, bool isDirectional, bool isHandleVisible)
     : m_base(base)
     , m_extent(extent)
     , m_affinity(affinity)
     , m_isDirectional(isDirectional)
     , m_granularity(CharacterGranularity)
     , m_hasTrailingWhitespace(false)
+    , m_isHandleVisible(isHandleVisible)
 {
     validate();
 }
 
 template <typename Strategy>
 VisibleSelectionTemplate<Strategy>::VisibleSelectionTemplate(const PositionWithAffinityTemplate<Strategy>& pos, bool isDirectional)
     : VisibleSelectionTemplate(pos.position(), pos.affinity(), isDirectional)
 {
 }
 
 template <typename Strategy>
 VisibleSelectionTemplate<Strategy>::VisibleSelectionTemplate(const VisiblePositionTemplate<Strategy>& pos, bool isDirectional)
     : VisibleSelectionTemplate(pos, pos, isDirectional)
 {
 }
 
 template <typename Strategy>
-VisibleSelectionTemplate<Strategy>::VisibleSelectionTemplate(const VisiblePositionTemplate<Strategy>& base, const VisiblePositionTemplate<Strategy>& extent, bool isDirectional)
-    : VisibleSelectionTemplate(base.deepEquivalent(), extent.deepEquivalent(), base.affinity(), isDirectional)
+VisibleSelectionTemplate<Strategy>::VisibleSelectionTemplate(const VisiblePositionTemplate<Strategy>& base, const VisiblePositionTemplate<Strategy>& extent, bool isDirectional, bool isHandleVisible)
+    : VisibleSelectionTemplate(base.deepEquivalent(), extent.deepEquivalent(), base.affinity(), isDirectional, isHandleVisible)
 {
 }
 
 template <typename Strategy>
 VisibleSelectionTemplate<Strategy>::VisibleSelectionTemplate(const EphemeralRangeTemplate<Strategy>& range, TextAffinity affinity, bool isDirectional)
     : VisibleSelectionTemplate(range.startPosition(), range.endPosition(), affinity, isDirectional)
 {
 }
 
 template <typename Strategy>
@@ skipping 20 matching lines @@
     : m_base(other.m_base)
     , m_extent(other.m_extent)
     , m_start(other.m_start)
     , m_end(other.m_end)
     , m_affinity(other.m_affinity)
     , m_selectionType(other.m_selectionType)
     , m_baseIsFirst(other.m_baseIsFirst)
     , m_isDirectional(other.m_isDirectional)
     , m_granularity(other.m_granularity)
     , m_hasTrailingWhitespace(other.m_hasTrailingWhitespace)
+    , m_isHandleVisible(other.m_isHandleVisible)
 {
 }
 
 template <typename Strategy>
 VisibleSelectionTemplate<Strategy>& VisibleSelectionTemplate<Strategy>::operator=(const VisibleSelectionTemplate<Strategy>& other)
 {
     m_base = other.m_base;
     m_extent = other.m_extent;
     m_start = other.m_start;
     m_end = other.m_end;
     m_affinity = other.m_affinity;
     m_selectionType = other.m_selectionType;
     m_baseIsFirst = other.m_baseIsFirst;
     m_isDirectional = other.m_isDirectional;
     m_granularity = other.m_granularity;
     m_hasTrailingWhitespace = other.m_hasTrailingWhitespace;
+    m_isHandleVisible = other.m_isHandleVisible;
     return *this;
 }
 
 template <typename Strategy>
 VisibleSelectionTemplate<Strategy> VisibleSelectionTemplate<Strategy>::selectionFromContentsOfNode(Node* node)
 {
     DCHECK(!Strategy::editingIgnoresContent(node));
     return VisibleSelectionTemplate(PositionTemplate<Strategy>::firstPositionInNode(node), PositionTemplate<Strategy>::lastPositionInNode(node));
 }
 
@@ skipping 597 matching lines @@
     if (!m_base.isConnected() || !m_extent.isConnected()) {
         *this = VisibleSelectionTemplate();
         return;
     }
     updateIfNeeded();
 }
 
 template <typename Strategy>
 static bool equalSelectionsAlgorithm(const VisibleSelectionTemplate<Strategy>& selection1, const VisibleSelectionTemplate<Strategy>& selection2)
 {
-    if (selection1.affinity() != selection2.affinity() || selection1.isDirectional() != selection2.isDirectional())
+    if (selection1.affinity() != selection2.affinity()
+        || selection1.isDirectional() != selection2.isDirectional()
+        || selection1.isHandleVisible() != selection2.isHandleVisible())
         return false;
 
     if (selection1.isNone())
         return selection2.isNone();
 
     const VisibleSelectionTemplate<Strategy> selectionWrapper1(selection1);
     const VisibleSelectionTemplate<Strategy> selectionWrapper2(selection2);
 
     return selectionWrapper1.start() == selectionWrapper2.start()
         && selectionWrapper1.end() == selectionWrapper2.end()
@@ skipping 119 matching lines @@
 {
     sel.showTreeForThis();
 }
 
 void showTree(const blink::VisibleSelectionInFlatTree* sel)
 {
     if (sel)
         sel->showTreeForThis();
 }
 #endif