Implement find in page support for top level BrowserPlugins.

extensions/browser/guest_view/mime_handler_view/mime_handler_view_guest.cc

 // Copyright 2014 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 "extensions/browser/guest_view/mime_handler_view/mime_handler_view_guest.h"
 
 #include "base/strings/stringprintf.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/common/url_constants.h"
@@ skipping 113 matching lines @@
       std::string());
 }
 
 void MimeHandlerViewGuest::DidInitialize() {
   extension_function_dispatcher_.reset(
       new ExtensionFunctionDispatcher(browser_context(), this));
   if (delegate_)
     delegate_->AttachHelpers();
 }
 
+bool MimeHandlerViewGuest::Find(int request_id,
+                                const base::string16& search_text,
+                                const blink::WebFindOptions& options,
+                                bool is_full_page_plugin) {
+  if (is_full_page_plugin) {
+    web_contents()->Find(request_id, search_text, options);
+    return true;
+  }
+  return false;
+}
+
 void MimeHandlerViewGuest::ContentsZoomChange(bool zoom_in) {
   if (delegate_)
     delegate_->ChangeZoom(zoom_in);
 }
 
 void MimeHandlerViewGuest::HandleKeyboardEvent(
     WebContents* source,
     const content::NativeWebKeyboardEvent& event) {
   if (!attached())
     return;
 
   // Send the keyboard events back to the embedder to reprocess them.
   // TODO(fsamuel): This introduces the possibility of out-of-order keyboard
   // events because the guest may be arbitrarily delayed when responding to
   // keyboard events. In that time, the embedder may have received and processed
   // additional key events. This needs to be fixed as soon as possible.
   // See http://crbug.com/229882.
   embedder_web_contents()->GetDelegate()->HandleKeyboardEvent(web_contents(),
                                                               event);
 }
 
+void MimeHandlerViewGuest::FindReply(content::WebContents* web_contents,
+                                     int request_id,
+                                     int number_of_matches,
+                                     const gfx::Rect& selection_rect,
+                                     int active_match_ordinal,
+                                     bool final_update) {
+  if (!attached() || !embedder_web_contents()->GetDelegate())
+    return;
+
+  embedder_web_contents()->GetDelegate()->FindReply(embedder_web_contents(),
+                                                    request_id,
+                                                    number_of_matches,
+                                                    selection_rect,
+                                                    active_match_ordinal,
+                                                    final_update);
+}
+
 bool MimeHandlerViewGuest::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(MimeHandlerViewGuest, message)
     IPC_MESSAGE_HANDLER(ExtensionHostMsg_Request, OnRequest)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void MimeHandlerViewGuest::OnRequest(
     const ExtensionHostMsg_Request_Params& params) {
   if (extension_function_dispatcher_) {
     extension_function_dispatcher_->Dispatch(
         params, web_contents()->GetRenderViewHost());
   }
 }
 
 }  // namespace extensions