Let WebKit draw the active highlight for FindInPage

webkit/glue/webframe_impl.cc

 /*
  * Copyright (C) 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 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
@@ skipping 952 matching lines @@
                         const WebFindOptions& options,
                         bool wrap_within_frame,
                         WebRect* selection_rect) {
   WebCore::String webcore_string = webkit_glue::String16ToString(search_text);
 
   WebFrameImpl* const main_frame_impl =
       static_cast<WebFrameImpl*>(GetView()->GetMainFrame());
 
   if (!options.findNext)
     frame()->page()->unmarkAllTextMatches();
+  else
+    SetMarkerActive(active_match_.get(), false);  // Active match is changing.
 
   // Starts the search from the current selection.
   bool start_in_selection = true;
 
+  // If the user has selected something since the last Find operation we want
+  // to start from there. Otherwise, we start searching from where the last Find
+  // operation left off (either a Find or a FindNext operation).
+  VisibleSelection selection(frame()->selection()->selection());
+  if (selection.isNone() && active_match_) {
+    selection = VisibleSelection(active_match_.get());
+    frame()->selection()->setSelection(selection);
+  }
+
   DCHECK(frame() && frame()->view());
   bool found = frame()->findString(webcore_string, options.forward,
                                    options.matchCase, wrap_within_frame,
                                    start_in_selection);
   if (found) {
-#if defined(OS_WIN)
-    WebCore::RenderThemeChromiumWin::setFindInPageMode(true);
-#endif
     // Store which frame was active. This will come in handy later when we
     // change the active match ordinal below.
     WebFrameImpl* old_active_frame = main_frame_impl->active_match_frame_;
     // Set this frame as the active frame (the one with the active highlight).
     main_frame_impl->active_match_frame_ = this;
 
     // We found something, so we can now query the selection for its position.
     VisibleSelection new_selection(frame()->selection()->selection());
     IntRect curr_selection_rect;
 
     // If we thought we found something, but it couldn't be selected (perhaps
     // because it was marked -webkit-user-select: none), we can't set it to
     // be active but we still continue searching. This matches Safari's
     // behavior, including some oddities when selectable and un-selectable text
     // are mixed on a page: see https://bugs.webkit.org/show_bug.cgi?id=19127.
     if (new_selection.isNone() ||
         (new_selection.start() == new_selection.end())) {
       active_match_ = NULL;
     } else {
       active_match_ = new_selection.toNormalizedRange();
       curr_selection_rect = active_match_->boundingBox();
+      SetMarkerActive(active_match_.get(), true);  // Active.
+      ClearSelection();  // WebKit draws the highlighting for all matches.
     }
 
     if (!options.findNext) {
       // This is a Find operation, so we set the flag to ask the scoping effort
       // to find the active rect for us so we can update the ordinal (n of m).
       locating_active_rect_ = true;
     } else {
       if (old_active_frame != this) {
         // If the active frame has changed it means that we have a multi-frame
         // page and we just switch to searching in a new frame. Then we just
@@ skipping 90 matching lines @@
     // 1125, 1688, 2K, 3K).
     static const int start_slowing_down_after = 500;
     static const int slowdown = 750;
     int i = (last_match_count_ / start_slowing_down_after);
     next_invalidate_after_ += i * slowdown;
 
     InvalidateArea(INVALIDATE_SCROLLBAR);
   }
 }
 
-void WebFrameImpl::AddMarker(WebCore::Range* range) {
+void WebFrameImpl::AddMarker(WebCore::Range* range, bool active_match) {
   // Use a TextIterator to visit the potentially multiple nodes the range
   // covers.
   TextIterator markedText(range);
   for (; !markedText.atEnd(); markedText.advance()) {
     RefPtr<Range> textPiece = markedText.range();
     int exception = 0;
 
     WebCore::DocumentMarker marker = {
         WebCore::DocumentMarker::TextMatch,
         textPiece->startOffset(exception),
         textPiece->endOffset(exception),
-        "" };
+        "",
+        active_match };
 
     if (marker.endOffset > marker.startOffset) {
       // Find the node to add a marker to and add it.
       Node* node = textPiece->startContainer(exception);
       frame()->document()->addMarker(node, marker);
 
       // Rendered rects for markers in WebKit are not populated until each time
       // the markers are painted. However, we need it to happen sooner, because
       // the whole purpose of tickmarks on the scrollbar is to show where
       // matches off-screen are (that haven't been painted yet).
       Vector<WebCore::DocumentMarker> markers =
           frame()->document()->markersForNode(node);
       frame()->document()->setRenderedRectForMarker(
           textPiece->startContainer(exception),
           markers[markers.size() - 1],
           range->boundingBox());
     }
   }
 }
 
+void WebFrameImpl::SetMarkerActive(WebCore::Range* range, bool active) {
+  if (!range)
+    return;
+
+  frame()->document()->setMarkersActive(range, active);
+}
+
 void WebFrameImpl::ScopeStringMatches(int request_id,
                                       const string16& search_text,
                                       const WebFindOptions& options,
                                       bool reset) {
   if (!ShouldScopeMatches(search_text))
     return;
 
   WebFrameImpl* main_frame_impl =
       static_cast<WebFrameImpl*>(GetView()->GetMainFrame());
 
@@ skipping 76 matching lines @@
     VisiblePosition new_start = endVisiblePosition(result_range.get(),
                                                    WebCore::DOWNSTREAM);
     if (new_start == startVisiblePosition(search_range.get(),
                                           WebCore::DOWNSTREAM))
       break;
 
     // Only treat the result as a match if it is visible
     if (frame()->editor()->insideVisibleArea(result_range.get())) {
       ++match_count;
 
-      AddMarker(result_range.get());
-
       setStart(search_range.get(), new_start);
       Node* shadow_tree_root = search_range->shadowTreeRootNode();
       if (search_range->collapsed(ec) && shadow_tree_root)
         search_range->setEnd(shadow_tree_root,
                              shadow_tree_root->childNodeCount(), ec);
 
       // Catch a special case where Find found something but doesn't know what
       // the bounding box for it is. In this case we set the first match we find
       // as the active rect.
       IntRect result_bounds = result_range->boundingBox();
       IntRect active_selection_rect;
       if (locating_active_rect_) {
         active_selection_rect = active_match_.get() ?
             active_match_->boundingBox() : result_bounds;
       }
 
       // If the Find function found a match it will have stored where the
       // match was found in active_selection_rect_ on the current frame. If we
       // find this rect during scoping it means we have found the active
       // tickmark.
+      bool found_active_match = false;
       if (locating_active_rect_ && (active_selection_rect == result_bounds)) {
         // We have found the active tickmark frame.
         main_frame_impl->active_match_frame_ = this;
+        found_active_match = true;
         // We also know which tickmark is active now.
         active_match_index_ = match_count - 1;
         // To stop looking for the active tickmark, we set this flag.
         locating_active_rect_ = false;
 
 #if defined(OS_WIN)
         // TODO(pinkerton): Fix Mac invalidation to be more like Win ScrollView
         // Notify browser of new location for the selected rectangle.
         result_bounds.move(-frameview()->scrollOffset().width(),
                            -frameview()->scrollOffset().height());
         ReportFindInPageSelection(
             webkit_glue::IntRectToWebRect(
                 frame()->view()->convertToContainingWindow(result_bounds)),
             active_match_index_ + 1,
             request_id);
 #endif
       }
+
+      AddMarker(result_range.get(), found_active_match);
     }
 
     resume_scoping_from_range_ = result_range;
     timeout = (Time::Now() - start_time).InMilliseconds() >= kTimeout;
   } while (!timeout);
 
   // Remember what we search for last time, so we can skip searching if more
   // letters are added to the search string (and last outcome was 0).
   last_search_string_ = search_text;
 
@@ skipping 85 matching lines @@
       }
     }
   }
 }
 
 void WebFrameImpl::StopFinding(bool clear_selection) {
   if (!clear_selection)
     SetFindEndstateFocusAndSelection();
   CancelPendingScopingEffort();
 
-#if defined(OS_WIN)
-  WebCore::RenderThemeChromiumWin::setFindInPageMode(false);
-#endif
-
   // Remove all markers for matches found and turn off the highlighting.
   if (this == static_cast<WebFrameImpl*>(GetView()->GetMainFrame()))
     frame()->document()->removeMarkers(WebCore::DocumentMarker::TextMatch);
   frame()->setMarkedTextMatchesAreHighlighted(false);
 
   // Let the frame know that we don't want tickmarks or highlighting anymore.
   InvalidateArea(INVALIDATE_ALL);
 }
 
 void WebFrameImpl::SelectAll() {
@@ skipping 570 matching lines @@
   return password_listeners_.get(input_element);
 }
 
 void WebFrameImpl::ClearPasswordListeners() {
   for (PasswordListenerMap::iterator iter = password_listeners_.begin();
        iter != password_listeners_.end(); ++iter) {
     delete iter->second;
   }
   password_listeners_.clear();
 }