Fix beep when navigating/closing a page with find bar open

content/browser/find_request_manager.cc

 // Copyright 2016 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/browser/find_request_manager.h"
 
 #include "content/browser/frame_host/render_frame_host_impl.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/common/frame_messages.h"
 #include "content/common/input_messages.h"
@@ skipping 175 matching lines @@
       active_frame_ = rfh;
       relative_active_match_ordinal_ = active_match_ordinal;
       UpdateActiveMatchOrdinal();
     }
     if (pending_active_match_ordinal_ && request_id == current_request_.id)
       pending_active_match_ordinal_ = false;
     AdvanceQueue(request_id);
   }
 
   if (!final_update) {
-    NotifyFindReply(request_id, false /* final_update */);
+    NotifyFindReply(request_id, false /* final_update */,
+                    false /* was_frame_removal */);
     return;
   }
 
   // This is the final update for this frame for the current find operation.
 
   pending_initial_replies_.erase(rfh);
   if (request_id == current_session_id_ && !pending_initial_replies_.empty()) {
-    NotifyFindReply(request_id, false /* final_update */);
+    NotifyFindReply(request_id, false /* final_update */,
+                    false /* was_frame_removal */);
     return;
   }
 
   // This is the final update for the current find operation.
 
   if (request_id == current_request_.id && request_id != current_session_id_) {
     DCHECK(current_request_.options.findNext);
     DCHECK_EQ(pending_find_next_reply_, rfh);
     pending_find_next_reply_ = nullptr;
   }
@@ skipping 37 matching lines @@
   // A reply should not be expected from the removed frame.
   RemoveNearestFindResultPendingReply(rfh);
   RemoveFindMatchRectsPendingReply(rfh);
 #endif
 
   // If no pending find replies are expected for the removed frame, then just
   // report the updated results.
   if (!pending_initial_replies_.count(rfh) && pending_find_next_reply_ != rfh) {
     bool final_update =
         pending_initial_replies_.empty() && !pending_find_next_reply_;
-    NotifyFindReply(current_session_id_, final_update);
+    NotifyFindReply(current_session_id_, final_update,
+                    true /* was_frame_removal */);
     return;
   }
 
   if (pending_initial_replies_.count(rfh)) {
     // A reply should not be expected from the removed frame.
     pending_initial_replies_.erase(rfh);
     if (pending_initial_replies_.empty()) {
       FinalUpdateReceived(current_session_id_, rfh);
     }
   }
@@ skipping 169 matching lines @@
 
   if (request.options.findNext)
     pending_find_next_reply_ = rfh;
   else
     pending_initial_replies_.insert(rfh);
 
   rfh->Send(new FrameMsg_Find(rfh->GetRoutingID(), request.id,
                               request.search_text, request.options));
 }
 
-void FindRequestManager::NotifyFindReply(int request_id, bool final_update) {
+void FindRequestManager::NotifyFindReply(int request_id,
+                                         bool final_update,
+                                         bool was_frame_removal) {
   if (request_id == kInvalidId) {
     NOTREACHED();
     return;
   }
 
   // Ensure that replies are not reported with IDs lower than the ID of the
   // latest request we have results from.
   if (request_id < last_reported_id_)
     request_id = last_reported_id_;
   else
     last_reported_id_ = request_id;
 
   contents_->NotifyFindReply(request_id, number_of_matches_, selection_rect_,
-                             active_match_ordinal_, final_update);
+                             active_match_ordinal_, final_update,
+                             was_frame_removal);
 }
 
 RenderFrameHost* FindRequestManager::GetInitialFrame(bool forward) const {
   RenderFrameHost* rfh = contents_->GetMainFrame();
 
   if (!forward)
     rfh = GetDeepestLastChild(rfh);
 
   return rfh;
 }
@@ skipping 66 matching lines @@
 
 void FindRequestManager::FinalUpdateReceived(int request_id,
                                              RenderFrameHost* rfh) {
   if (!number_of_matches_ ||
       (active_match_ordinal_ && !pending_active_match_ordinal_) ||
       pending_find_next_reply_) {
     // All the find results for |request_id| are in and ready to report. Note
     // that |final_update| will be set to false if there are still pending
     // replies expected from the initial find request.
     NotifyFindReply(request_id,
-                    pending_initial_replies_.empty() /* final_update */);
+                    pending_initial_replies_.empty() /* final_update */,
+                    false /* was_frame_removal */);
     AdvanceQueue(request_id);
     return;
   }
 
   // There are matches, but no active match was returned, so another find next
   // request must be sent.
 
   RenderFrameHost* target_rfh;
   if (request_id == current_request_.id && current_request_.options.findNext) {
     // If this was a find next operation, then the active match will be in the
@@ skipping 16 matching lines @@
       target_rfh = Traverse(target_rfh,
                             current_request_.options.forward,
                             true /* matches_only */,
                             false /* wrap */);
     }
   }
   DCHECK(target_rfh);
 
   // Forward the find reply without |final_update| set because the active match
   // has not yet been found.
-  NotifyFindReply(request_id, false /* final_update */);
+  NotifyFindReply(request_id, false /* final_update */,
+                  false /* was_frame_removal */);
 
   current_request_.options.findNext = true;
   SendFindIPC(current_request_, target_rfh);
 }
 
 #if defined(OS_ANDROID)
 void FindRequestManager::RemoveNearestFindResultPendingReply(
     RenderFrameHost* rfh) {
   auto it = activate_.pending_replies.find(rfh);
   if (it == activate_.pending_replies.end())
@@ skipping 35 matching lines @@
             aggregate_rects.end(), frame_rects.begin(), frame_rects.end());
       }
     }
     contents_->NotifyFindMatchRectsReply(
         match_rects_.known_version, aggregate_rects, match_rects_.active_rect);
   }
 }
 #endif
 
 }  // namespace content