Fix issue 5079: Incorrect "Active match ordinal" count during Find-in-page...

chrome/browser/automation/automation_provider.cc

 // Copyright (c) 2006-2008 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 "chrome/browser/automation/automation_provider.h"
 
 #include "base/path_service.h"
 #include "chrome/app/chrome_dll_resource.h" 
 #include "chrome/browser/automation/automation_provider_list.h"
 #include "chrome/browser/automation/ui_controls.h"
@@ skipping 392 matching lines @@
   int32 routing_id_;
 };
 
 class FindInPageNotificationObserver : public NotificationObserver {
  public:
   FindInPageNotificationObserver(AutomationProvider* automation,
                                  TabContents* parent_tab,
                                  int32 routing_id)
       : automation_(automation),
         parent_tab_(parent_tab),
-        routing_id_(routing_id) {
+        routing_id_(routing_id),
+        active_match_ordinal_(-1) {
     NotificationService::current()->
         AddObserver(this, NOTIFY_FIND_RESULT_AVAILABLE,
                     Source<TabContents>(parent_tab_));
   }
 
   ~FindInPageNotificationObserver() {
     Unregister();
   }
 
   void Unregister() {
     NotificationService::current()->
         RemoveObserver(this, NOTIFY_FIND_RESULT_AVAILABLE,
                        Source<TabContents>(parent_tab_));
   }
 
   virtual void Observe(NotificationType type, const NotificationSource& source,
       const NotificationDetails& details) {
     if (type == NOTIFY_FIND_RESULT_AVAILABLE) {
       Details<FindNotificationDetails> find_details(details);
       if (find_details->request_id() == kFindInPageRequestId) {
+        // We get multiple responses and one of those will contain the ordinal.
+        // This message comes to us before the final update is sent.
+        if (find_details->active_match_ordinal() > -1)
+          active_match_ordinal_ = find_details->active_match_ordinal();
         if (find_details->final_update()) {
-          automation_->Send(new AutomationMsg_FindInPageResponse(routing_id_,
+          automation_->Send(new AutomationMsg_FindInPageResponse2(routing_id_,
+              active_match_ordinal_,
               find_details->number_of_matches()));
         } else {
           DLOG(INFO) << "Ignoring, since we only care about the final message";
         }
       }
     } else {
       NOTREACHED();
     }
   }
 
   // The Find mechanism is over asynchronous IPC, so a search is kicked off and
   // we wait for notification to find out what the results are. As the user is
   // typing, new search requests can be issued and the Request ID helps us make
   // sense of whether this is the current request or an old one. The unit tests,
   // however, which uses this constant issues only one search at a time, so we
   // don't need a rolling id to identify each search. But, we still need to
   // specify one, so we just use a fixed one - its value does not matter.
   static const int kFindInPageRequestId;
  private:
   AutomationProvider* automation_;
   TabContents* parent_tab_;
   int32 routing_id_;
+  // We will at some point (before final update) be notified of the ordinal and
+  // we need to preserve it so we can send it later.
+  int active_match_ordinal_;
 };
 
 const int FindInPageNotificationObserver::kFindInPageRequestId = -1;
 
 class DomOperationNotificationObserver : public NotificationObserver {
  public:
   explicit DomOperationNotificationObserver(AutomationProvider* automation)
       : automation_(automation) {
     NotificationService::current()->
         AddObserver(this, NOTIFY_DOM_OPERATION_RESPONSE,
@@ skipping 1237 matching lines @@
 
   Send(new AutomationMsg_ConstrainedWindowBoundsResponse(message.routing_id(),
                                                          exists, rect));
 }
 
 void AutomationProvider::HandleFindInPageRequest(
     const IPC::Message& message, int handle, const std::wstring& find_request,
     int forward, int match_case) {
   NOTREACHED() << "This function has been deprecated."
     << "Please use HandleFindRequest instead.";
-  Send(new AutomationMsg_FindInPageResponse(message.routing_id(), -1));
+  Send(new AutomationMsg_FindInPageResponse2(message.routing_id(), -1, -1));
   return;
 }
 
 void AutomationProvider::HandleFindRequest(const IPC::Message& message,
     int handle, const FindInPageRequest& request) {
   if (!tab_tracker_->ContainsHandle(handle)) {
-    Send(new AutomationMsg_FindInPageResponse(message.routing_id(), -1));
+    Send(new AutomationMsg_FindInPageResponse2(message.routing_id(), -1, -1));
     return;
   }
 
   NavigationController* nav = tab_tracker_->GetResource(handle);
   TabContents* tab_contents = nav->active_contents();
 
   find_in_page_observer_.reset(new
       FindInPageNotificationObserver(this, tab_contents, message.routing_id()));
 
   // The find in page dialog must be up for us to get the notification that the
@@ skipping 705 matching lines @@
                                           int value) {
   bool success = false;
   if (browser_tracker_->ContainsHandle(handle)) {
     Browser* browser = browser_tracker_->GetResource(handle);
     browser->profile()->GetPrefs()->SetInteger(name.c_str(), value);
     success = true;
   }
   Send(new AutomationMsg_SetIntPreferenceResponse(message.routing_id(),
                                                   success));
 }