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

content/renderer/render_view_impl.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 "content/renderer/render_view_impl.h"
 
 #include <algorithm>
 #include <cmath>
 #include <string>
 #include <vector>
@@ skipping 599 matching lines @@
       media_stream_dispatcher_(NULL),
       media_stream_impl_(NULL),
       devtools_agent_(NULL),
       accessibility_mode_(AccessibilityModeOff),
       renderer_accessibility_(NULL),
       java_bridge_dispatcher_(NULL),
       mouse_lock_dispatcher_(NULL),
 #if defined(OS_ANDROID)
       expected_content_intent_id_(0),
       media_player_proxy_(NULL),
+      synchronous_find_active_match_ordinal_(-1),
 #endif
       session_storage_namespace_id_(session_storage_namespace_id),
       handling_select_range_(false),
 #if defined(OS_WIN)
       focused_plugin_id_(-1),
 #endif
       guest_to_embedder_channel_(guest_to_embedder_channel),
       guest_pp_instance_(0),
       guest_uninitialized_context_(NULL),
       updating_frame_tree_(false),
@@ skipping 307 matching lines @@
   bool handled = true;
   bool msg_is_ok = true;
   IPC_BEGIN_MESSAGE_MAP_EX(RenderViewImpl, message, msg_is_ok)
     IPC_MESSAGE_HANDLER(ViewMsg_Navigate, OnNavigate)
     IPC_MESSAGE_HANDLER(ViewMsg_Stop, OnStop)
     IPC_MESSAGE_HANDLER(ViewMsg_ReloadFrame, OnReloadFrame)
     IPC_MESSAGE_HANDLER(ViewMsg_Undo, OnUndo)
     IPC_MESSAGE_HANDLER(ViewMsg_Redo, OnRedo)
     IPC_MESSAGE_HANDLER(ViewMsg_Cut, OnCut)
     IPC_MESSAGE_HANDLER(ViewMsg_Copy, OnCopy)
-#if defined(OS_MACOSX)
-    IPC_MESSAGE_HANDLER(ViewMsg_CopyToFindPboard, OnCopyToFindPboard)
-#endif
     IPC_MESSAGE_HANDLER(ViewMsg_Paste, OnPaste)
     IPC_MESSAGE_HANDLER(ViewMsg_PasteAndMatchStyle, OnPasteAndMatchStyle)
     IPC_MESSAGE_HANDLER(ViewMsg_Replace, OnReplace)
     IPC_MESSAGE_HANDLER(ViewMsg_Delete, OnDelete)
     IPC_MESSAGE_HANDLER(ViewMsg_SelectAll, OnSelectAll)
     IPC_MESSAGE_HANDLER(ViewMsg_ReplaceAll, OnReplaceAll)
     IPC_MESSAGE_HANDLER(ViewMsg_Unselect, OnUnselect)
     IPC_MESSAGE_HANDLER(ViewMsg_SetEditableSelectionOffsets,
                         OnSetEditableSelectionOffsets)
     IPC_MESSAGE_HANDLER(ViewMsg_SetCompositionFromExistingText,
                         OnSetCompositionFromExistingText)
     IPC_MESSAGE_HANDLER(ViewMsg_ExtendSelectionAndDelete,
                         OnExtendSelectionAndDelete)
     IPC_MESSAGE_HANDLER(ViewMsg_SelectRange, OnSelectRange)
     IPC_MESSAGE_HANDLER(ViewMsg_CopyImageAt, OnCopyImageAt)
     IPC_MESSAGE_HANDLER(ViewMsg_ExecuteEditCommand, OnExecuteEditCommand)
     IPC_MESSAGE_HANDLER(ViewMsg_Find, OnFind)
     IPC_MESSAGE_HANDLER(ViewMsg_StopFinding, OnStopFinding)
-#if defined(OS_ANDROID)
-    IPC_MESSAGE_HANDLER(ViewMsg_ActivateNearestFindResult,
-                        OnActivateNearestFindResult)
-    IPC_MESSAGE_HANDLER(ViewMsg_FindMatchRects,
-                        OnFindMatchRects)
-#endif
     IPC_MESSAGE_HANDLER(ViewMsg_Zoom, OnZoom)
     IPC_MESSAGE_HANDLER(ViewMsg_SetZoomLevel, OnSetZoomLevel)
     IPC_MESSAGE_HANDLER(ViewMsg_ZoomFactor, OnZoomFactor)
     IPC_MESSAGE_HANDLER(ViewMsg_SetZoomLevelForLoadingURL,
                         OnSetZoomLevelForLoadingURL)
     IPC_MESSAGE_HANDLER(ViewMsg_SetPageEncoding, OnSetPageEncoding)
     IPC_MESSAGE_HANDLER(ViewMsg_ResetPageEncodingToDefault,
                         OnResetPageEncodingToDefault)
     IPC_MESSAGE_HANDLER(ViewMsg_ScriptEvalRequest, OnScriptEvalRequest)
     IPC_MESSAGE_HANDLER(ViewMsg_PostMessageEvent, OnPostMessageEvent)
@@ skipping 32 matching lines @@
     IPC_MESSAGE_HANDLER(ViewMsg_DisableScrollbarsForSmallWindows,
                         OnDisableScrollbarsForSmallWindows)
     IPC_MESSAGE_HANDLER(ViewMsg_SetRendererPrefs, OnSetRendererPrefs)
     IPC_MESSAGE_HANDLER(ViewMsg_MediaPlayerActionAt, OnMediaPlayerActionAt)
     IPC_MESSAGE_HANDLER(ViewMsg_OrientationChangeEvent,
                         OnOrientationChangeEvent)
     IPC_MESSAGE_HANDLER(ViewMsg_PluginActionAt, OnPluginActionAt)
     IPC_MESSAGE_HANDLER(ViewMsg_SetActive, OnSetActive)
     IPC_MESSAGE_HANDLER(ViewMsg_SetNavigationStartTime,
                         OnSetNavigationStartTime)
-#if defined(OS_MACOSX)
-    IPC_MESSAGE_HANDLER(ViewMsg_SetWindowVisibility, OnSetWindowVisibility)
-    IPC_MESSAGE_HANDLER(ViewMsg_WindowFrameChanged, OnWindowFrameChanged)
-    IPC_MESSAGE_HANDLER(ViewMsg_PluginImeCompositionCompleted,
-                        OnPluginImeCompositionCompleted)
-#endif
     IPC_MESSAGE_HANDLER(ViewMsg_SetEditCommandsForNextKeyEvent,
                         OnSetEditCommandsForNextKeyEvent)
     IPC_MESSAGE_HANDLER(ViewMsg_CustomContextMenuAction,
                         OnCustomContextMenuAction)
     IPC_MESSAGE_HANDLER(ViewMsg_AsyncOpenFile_ACK, OnAsyncFileOpened)
     IPC_MESSAGE_HANDLER(ViewMsg_PpapiBrokerChannelCreated,
                         OnPpapiBrokerChannelCreated)
     IPC_MESSAGE_HANDLER(ViewMsg_PpapiBrokerPermissionResult,
                         OnPpapiBrokerPermissionResult)
     IPC_MESSAGE_HANDLER(ViewMsg_GetAllSavableResourceLinksForCurrentPage,
                         OnGetAllSavableResourceLinksForCurrentPage)
     IPC_MESSAGE_HANDLER(
         ViewMsg_GetSerializedHtmlDataForCurrentPageWithLocalLinks,
         OnGetSerializedHtmlDataForCurrentPageWithLocalLinks)
-#if defined(OS_MACOSX)
-    IPC_MESSAGE_HANDLER(ViewMsg_SelectPopupMenuItem, OnSelectPopupMenuItem)
-#elif defined(OS_ANDROID)
-    IPC_MESSAGE_HANDLER(ViewMsg_SelectPopupMenuItems, OnSelectPopupMenuItems)
-#endif
     IPC_MESSAGE_HANDLER(ViewMsg_ContextMenuClosed, OnContextMenuClosed)
     // TODO(viettrungluu): Move to a separate message filter.
-#if defined(OS_MACOSX)
-    IPC_MESSAGE_HANDLER(ViewMsg_SetInLiveResize, OnSetInLiveResize)
-#endif
     IPC_MESSAGE_HANDLER(ViewMsg_SetHistoryLengthAndPrune,
                         OnSetHistoryLengthAndPrune)
     IPC_MESSAGE_HANDLER(ViewMsg_EnableViewSourceMode, OnEnableViewSourceMode)
     IPC_MESSAGE_HANDLER(JavaBridgeMsg_Init, OnJavaBridgeInit)
     IPC_MESSAGE_HANDLER(ViewMsg_SetAccessibilityMode, OnSetAccessibilityMode)
     IPC_MESSAGE_HANDLER(ViewMsg_UpdateFrameTree, OnUpdatedFrameTree)
+#if defined(OS_ANDROID)
+    IPC_MESSAGE_HANDLER(ViewMsg_ActivateNearestFindResult,
+                        OnActivateNearestFindResult)
+    IPC_MESSAGE_HANDLER(ViewMsg_FindMatchRects, OnFindMatchRects)
+    IPC_MESSAGE_HANDLER(ViewMsg_SelectPopupMenuItems, OnSelectPopupMenuItems)
+    IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewMsg_SynchronousFind, OnSynchronousFind)
+#elif defined(OS_MACOSX)
+    IPC_MESSAGE_HANDLER(ViewMsg_CopyToFindPboard, OnCopyToFindPboard)
+    IPC_MESSAGE_HANDLER(ViewMsg_PluginImeCompositionCompleted,
+                        OnPluginImeCompositionCompleted)
+    IPC_MESSAGE_HANDLER(ViewMsg_SelectPopupMenuItem, OnSelectPopupMenuItem)
+    IPC_MESSAGE_HANDLER(ViewMsg_SetInLiveResize, OnSetInLiveResize)
+    IPC_MESSAGE_HANDLER(ViewMsg_SetWindowVisibility, OnSetWindowVisibility)
+    IPC_MESSAGE_HANDLER(ViewMsg_WindowFrameChanged, OnWindowFrameChanged)
+#endif
 
     // Have the super handle all other messages.
     IPC_MESSAGE_UNHANDLED(handled = RenderWidget::OnMessageReceived(message))
   IPC_END_MESSAGE_MAP()
 
   if (!msg_is_ok) {
     // The message had a handler, but its deserialization failed.
     // Kill the renderer to avoid potential spoofing attacks.
     CHECK(false) << "Unable to deserialize message in RenderViewImpl.";
   }
@@ skipping 2844 matching lines @@
 }
 
 void RenderViewImpl::numberOfWheelEventHandlersChanged(unsigned num_handlers) {
   Send(new ViewHostMsg_DidChangeNumWheelEvents(routing_id_, num_handlers));
 }
 
 void RenderViewImpl::hasTouchEventHandlers(bool has_handlers) {
   Send(new ViewHostMsg_HasTouchEventHandlers(routing_id_, has_handlers));
 }
 
-void RenderViewImpl::reportFindInPageMatchCount(int request_id, int count,
+void RenderViewImpl::SendFindReply(int request_id,
+                                   int match_count,
+                                   int ordinal,
+                                   const WebRect& selection_rect,
+                                   bool final_status_update) {
+#if defined(OS_ANDROID)
+  if (synchronous_find_reply_message_.get()) {
+    if (final_status_update) {
+      ViewMsg_SynchronousFind::WriteReplyParams(
+          synchronous_find_reply_message_.get(),
+          match_count,
+          match_count ? synchronous_find_active_match_ordinal_ : 0);
+      Send(synchronous_find_reply_message_.release());
+    }
+    return;
+  }
+#endif
+
+  Send(new ViewHostMsg_Find_Reply(routing_id_,
+                                  request_id,
+                                  match_count,
+                                  selection_rect,
+                                  ordinal,
+                                  final_status_update));
+}
+
+void RenderViewImpl::reportFindInPageMatchCount(int request_id,
+                                                int count,
                                                 bool final_update) {
   int active_match_ordinal = -1;  // -1 = don't update active match ordinal
   if (!count)
     active_match_ordinal = 0;
 
-  Send(new ViewHostMsg_Find_Reply(routing_id_,
-                                  request_id,
-                                  count,
-                                  gfx::Rect(),
-                                  active_match_ordinal,
-                                  final_update));
+  // Send the search result over to the browser process.
+  SendFindReply(request_id,
+                count,
+                active_match_ordinal,
+                gfx::Rect(),
+                final_update);
 }
 
 void RenderViewImpl::reportFindInPageSelection(int request_id,
                                                int active_match_ordinal,
                                                const WebRect& selection_rect) {
-  // Send the search result over to the browser process.
-  Send(new ViewHostMsg_Find_Reply(routing_id_,
-                                  request_id,
-                                  -1,
-                                  selection_rect,
-                                  active_match_ordinal,
-                                  false));
+#if defined(OS_ANDROID)
+  // If this was a SynchronousFind request, we need to remember the ordinal
+  // value here for replying when reportFindInPageMatchCount is called.
+  if (synchronous_find_reply_message_.get()) {
+    synchronous_find_active_match_ordinal_ = active_match_ordinal;
+    return;
+  }
+#endif
+
+  SendFindReply(request_id,
+                -1,
+                active_match_ordinal,
+                selection_rect,
+                false);
 }
 
 void RenderViewImpl::openFileSystem(
     WebFrame* frame,
     WebFileSystem::Type type,
     long long size,
     bool create,
     WebFileSystemCallbacks* callbacks) {
   DCHECK(callbacks);
 
@@ skipping 587 matching lines @@
     web_ui_bindings_.reset(new WebUIBindings(
         static_cast<content::RenderView*>(this), routing_id_));
   }
   return web_ui_bindings_.get();
 }
 
 WebKit::WebPlugin* RenderViewImpl::GetWebPluginFromPluginDocument() {
   return webview()->mainFrame()->document().to<WebPluginDocument>().plugin();
 }
 
-void RenderViewImpl::OnFind(int request_id, const string16& search_text,
+void RenderViewImpl::OnFind(int request_id,
+                            const string16& search_text,
                             const WebFindOptions& options) {
+#if defined(OS_ANDROID)
+  // Make sure any asynchronous messages do not disrupt an ongoing synchronous
+  // find request as it might lead to deadlocks. Also, these should be safe to
+  // ignore since they would belong to a previous find request.
+  if (synchronous_find_reply_message_.get())
+    return;
+#endif
+  Find(request_id, search_text, options);
+}
+
+void RenderViewImpl::Find(int request_id,
+                          const string16& search_text,
+                          const WebFindOptions& options) {
   WebFrame* main_frame = webview()->mainFrame();
 
   // Check if the plugin still exists in the document.
   if (main_frame->document().isPluginDocument() &&
       GetWebPluginFromPluginDocument()) {
     if (options.findNext) {
       // Just navigate back/forward.
       GetWebPluginFromPluginDocument()->selectFindResult(options.forward);
     } else {
-      if (GetWebPluginFromPluginDocument()->startFind(
+      if (!GetWebPluginFromPluginDocument()->startFind(
           search_text, options.matchCase, request_id)) {
-      } else {
         // Send "no results".
-        Send(new ViewHostMsg_Find_Reply(routing_id_,
-                                        request_id,
-                                        0,
-                                        gfx::Rect(),
-                                        0,
-                                        true));
+        SendFindReply(request_id, 0, 0, gfx::Rect(), true);
       }
     }
     return;
   }
 
   WebFrame* frame_after_main = main_frame->traverseNext(true);
   WebFrame* focused_frame = webview()->focusedFrame();
   WebFrame* search_frame = focused_frame;  // start searching focused frame.
 
   bool multi_frame = (frame_after_main != main_frame);
@@ skipping 52 matching lines @@
     // If nothing is found, set result to "0 of 0", otherwise, set it to
     // "-1 of 1" to indicate that we found at least one item, but we don't know
     // yet what is active.
     int ordinal = result ? -1 : 0;  // -1 here means, we might know more later.
     int match_count = result ? 1 : 0;  // 1 here means possibly more coming.
 
     // If we find no matches then this will be our last status update.
     // Otherwise the scoping effort will send more results.
     bool final_status_update = !result;
 
-    // Send the search result over to the browser process.
-    Send(new ViewHostMsg_Find_Reply(routing_id_,
-                                    request_id,
-                                    match_count,
-                                    selection_rect,
-                                    ordinal,
-                                    final_status_update));
+    SendFindReply(request_id, match_count, ordinal, selection_rect,
+                  final_status_update);
 
     // Scoping effort begins, starting with the mainframe.
     search_frame = main_frame;
 
     main_frame->resetMatchCount();
 
     do {
       // Cancel all old scoping requests before starting a new one.
       search_frame->cancelPendingScopingEffort();
 
       // We don't start another scoping effort unless at least one match has
       // been found.
       if (result) {
         // Start new scoping request. If the scoping function determines that it
         // needs to scope, it will defer until later.
         search_frame->scopeStringMatches(request_id,
                                          search_text,
                                          options,
                                          true);  // reset the tickmarks
       }
 
       // Iterate to the next frame. The frame will not necessarily scope, for
       // example if it is not visible.
       search_frame = search_frame->traverseNext(true);
     } while (search_frame != main_frame);
   }
 }
 
 void RenderViewImpl::OnStopFinding(content::StopFindAction action) {
+#if defined(OS_ANDROID)
+  // Make sure any asynchronous messages do not disrupt an ongoing synchronous
+  // find request as it might lead to deadlocks. Also, these should be safe to
+  // ignore since they would belong to a previous find request.
+  if (synchronous_find_reply_message_.get())
+    return;
+#endif
+
+  StopFinding(action);
+}
+
+void RenderViewImpl::StopFinding(content::StopFindAction action) {
   WebView* view = webview();
   if (!view)
     return;
 
   WebDocument doc = view->mainFrame()->document();
   if (doc.isPluginDocument() && GetWebPluginFromPluginDocument()) {
     GetWebPluginFromPluginDocument()->stopFind();
     return;
   }
 
@@ skipping 14 matching lines @@
       if (!doc.isNull()) {
         WebNode node = doc.focusedNode();
         if (!node.isNull())
           node.simulateClick();
       }
     }
   }
 }
 
 #if defined(OS_ANDROID)
+void RenderViewImpl::OnSynchronousFind(int request_id,
+                                       const string16& search_string,
+                                       const WebFindOptions& options,
+                                       IPC::Message* reply_msg) {
+  // It is impossible for simultaneous blocking finds to occur.
+  CHECK(!synchronous_find_reply_message_.get());
+  synchronous_find_reply_message_.reset(reply_msg);
+
+  // Find next should be asynchronous in order to minimize blocking
+  // the UI thread as much as possible.
+  DCHECK(!options.findNext);
+  StopFinding(content::STOP_FIND_ACTION_KEEP_SELECTION);
+  synchronous_find_active_match_ordinal_ = -1;
+
+  Find(request_id, search_string, options);
+}
+
 void RenderViewImpl::OnActivateNearestFindResult(int request_id,
                                                  float x, float y) {
   if (!webview())
       return;
 
   WebFrame* main_frame = webview()->mainFrame();
   WebRect selection_rect;
   int ordinal = main_frame->selectNearestFindMatch(WebFloatPoint(x, y),
                                                    &selection_rect);
   if (ordinal == -1) {
     // Something went wrong, so send a no-op reply (force the main_frame to
     // report the current match count) in case the host is waiting for a
     // response due to rate-limiting).
     main_frame->increaseMatchCount(0, request_id);
     return;
   }
 
-  Send(new ViewHostMsg_Find_Reply(routing_id_,
-                                  request_id,
-                                  -1 /* number_of_matches */,
-                                  selection_rect,
-                                  ordinal,
-                                  true /* final_update */));
+  SendFindReply(request_id,
+                -1 /* number_of_matches */,
+                ordinal,
+                selection_rect,
+                true /* final_update */);
 }
 
 void RenderViewImpl::OnFindMatchRects(int current_version) {
   if (!webview())
       return;
 
   WebFrame* main_frame = webview()->mainFrame();
   std::vector<gfx::RectF> match_rects;
 
   int rects_version = main_frame->findMatchMarkersVersion();
@@ skipping 1425 matching lines @@
 
   updating_frame_tree_ = true;
   active_frame_id_map_.clear();
 
   target_process_id_ = process_id;
   target_routing_id_ = route_id;
   CreateFrameTree(webview()->mainFrame(), frames);
 
   updating_frame_tree_ = false;
 }