[Android] Upstream the WebView find-in-page API implementation.

android_webview/browser/find_helper.cc

+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "android_webview/browser/find_helper.h"
+
+#include "android_webview/browser/scoped_allow_wait_for_legacy_web_view_api.h"
+#include "base/message_loop.h"
+#include "content/public/browser/render_view_host.h"
+#include "content/public/browser/web_contents.h"
+#include "content/public/common/stop_find_action.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebFindOptions.h"
+
+using content::WebContents;
+using WebKit::WebFindOptions;
+
+namespace android_webview {
+
+FindHelper::FindHelper(WebContents* web_contents)
+    : WebContentsObserver(web_contents),
+      listener_(NULL),
+      async_find_started_(false),
+      sync_find_started_(false),
+      find_request_id_counter_(0),
+      current_request_id_(0),
+      last_match_count_(-1),
+      last_active_ordinal_(-1),
+      weak_factory_(this) {
+}
+
+FindHelper::~FindHelper() {
+}
+
+void FindHelper::SetListener(Listener* listener) {
+  listener_ = listener;
+}
+
+int FindHelper::FindAllSync(const string16& search_string) {
+  sync_find_started_ = true;
+  async_find_started_ = false;
+
+  WebFindOptions options;
+  options.forward = true;
+  options.matchCase = false;
+  options.findNext = false;
+
+  int match_count = 0;
+  int active_ordinal = 0;
+
+  StartNewRequest(search_string);
+
+  // Any ongoing asynchronous requests will be stopped in the renderer when
+  // calling SynchronousFind. Using the asynchronous StopFinding message could
+  // lead to deadblocks as the message could arrive in the middle of the
+  // synchronous operation and cancel the reply back.
+  ScopedAllowWaitForLegacyWebViewApi wait;
+  web_contents()->GetRenderViewHost()->SynchronousFind(current_request_id_,
+                                                       search_string,
+                                                       options,
+                                                       &match_count,
+                                                       &active_ordinal);
+
+  // Post the task to ourselves to prevent trigerring the notification before
+  // we actually return from the request.
+  MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&FindHelper::NotifyResults, weak_factory_.GetWeakPtr(),
+          active_ordinal, match_count, true));
+
+  return match_count;
+}
+
+void FindHelper::FindAllAsync(const string16& search_string) {
+  // Stop any ongoing asynchronous request.
+  web_contents()->GetRenderViewHost()->StopFinding(
+      content::STOP_FIND_ACTION_KEEP_SELECTION);
+
+  sync_find_started_ = false;
+  async_find_started_ = true;
+
+  WebFindOptions options;
+  options.forward = true;
+  options.matchCase = false;
+  options.findNext = false;
+
+  StartNewRequest(search_string);
+  web_contents()->GetRenderViewHost()->Find(current_request_id_,
+                                            search_string, options);
+}
+
+void FindHelper::HandleFindReply(int request_id,
+                                   int match_count,
+                                   int active_ordinal,
+                                   bool finished) {
+  if ((!async_find_started_ && !sync_find_started_) ||
+      request_id != current_request_id_) {
+    return;
+  }
+
+  NotifyResults(active_ordinal, match_count, finished);
+}
+
+void FindHelper::FindNext(bool forward) {
+  if (!sync_find_started_ && !async_find_started_)
+    return;
+
+  WebFindOptions options;
+  options.forward = forward;
+  options.matchCase = false;
+  options.findNext = true;
+
+  web_contents()->GetRenderViewHost()->Find(current_request_id_,
+                                            last_search_string_,
+                                            options);
+}
+
+void FindHelper::ClearMatches() {
+  web_contents()->GetRenderViewHost()->StopFinding(
+      content::STOP_FIND_ACTION_CLEAR_SELECTION);
+
+  sync_find_started_ = false;
+  async_find_started_ = false;
+  last_search_string_.clear();
+  last_match_count_ = -1;
+  last_active_ordinal_ = -1;
+}
+
+void FindHelper::StartNewRequest(const string16& search_string) {
+  current_request_id_ = find_request_id_counter_++;
+  last_search_string_ = search_string;
+  last_match_count_ = -1;
+  last_active_ordinal_ = -1;
+}
+
+void FindHelper::NotifyResults(int active_ordinal,
+                                 int match_count,
+                                 bool finished) {
+  // Match count or ordinal values set to -1 refer to the received replies.
+  if (match_count == -1)
+    match_count = last_match_count_;
+  else
+    last_match_count_ = match_count;
+
+  if (active_ordinal == -1)
+    active_ordinal = last_active_ordinal_;
+  else
+    last_active_ordinal_ = active_ordinal;
+
+  // Skip the update if we don't still have a valid ordinal.
+  // The next update, final or not, should have this information.
+  if (!finished && active_ordinal == -1)
+    return;
+
+  // Safeguard in case of errors to prevent reporting -1 to the API listeners.
+  if (match_count == -1) {
+    NOTREACHED();
+    match_count = 0;
+  }
+
+  if (active_ordinal == -1) {
+    NOTREACHED();
+    active_ordinal = 0;
+  }
+
+  // WebView.FindListener active match ordinals are 0-based while WebKit sends
+  // 1-based ordinals. Still we can receive 0 ordinal in case of no results.
+  active_ordinal = std::max(active_ordinal - 1, 0);
+
+  if (listener_)
+    listener_->OnFindResultReceived(active_ordinal, match_count, finished);
+}
+
+}  // namespace android_webview