Remove swapped out state from RenderFrameImpl.

content/renderer/render_frame_impl.cc

 // Copyright 2013 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_frame_impl.h"
 
 #include <map>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 960 matching lines @@
 }
 
 // RenderFrameImpl ----------------------------------------------------------
 RenderFrameImpl::RenderFrameImpl(const CreateParams& params)
     : frame_(NULL),
       is_main_frame_(true),
       in_browser_initiated_detach_(false),
       in_frame_tree_(false),
       render_view_(params.render_view->AsWeakPtr()),
       routing_id_(params.routing_id),
-      is_swapped_out_(false),
       render_frame_proxy_(NULL),
       is_detaching_(false),
       proxy_routing_id_(MSG_ROUTING_NONE),
 #if defined(ENABLE_PLUGINS)
       plugin_power_saver_helper_(nullptr),
       plugin_find_handler_(nullptr),
 #endif
       cookie_jar_(this),
       selection_text_offset_(0),
       selection_range_(gfx::Range::InvalidRange()),
@@ skipping 98 matching lines @@
                  "parent", parent_id);
   }
 
   MaybeEnableMojoBindings();
 
 #if defined(ENABLE_PLUGINS)
   new PepperBrowserConnection(this);
 #endif
   new SharedWorkerRepository(this);
 
-  if (IsLocalRoot() && !is_swapped_out_) {
+  if (IsLocalRoot()) {
     // DevToolsAgent is a RenderFrameObserver, and will destruct itself
     // when |this| is deleted.
     devtools_agent_ = new DevToolsAgent(this);
   }
 
   RegisterMojoServices();
 
   // We delay calling this until we have the WebFrame so that any observer or
   // embedder can call GetWebFrame on any RenderFrame.
   GetContentClient()->renderer()->RenderFrameCreated(this);
@@ skipping 194 matching lines @@
     InitializeUserMediaClient();
   return web_user_media_client_ ?
       web_user_media_client_->media_stream_dispatcher() : NULL;
 }
 
 bool RenderFrameImpl::Send(IPC::Message* message) {
   if (is_detaching_) {
     delete message;
     return false;
   }
-  if (is_swapped_out_) {
-    if (!SwappedOutMessages::CanSendWhileSwappedOut(message)) {
-      delete message;
-      return false;
-    }
-  }
 
   return RenderThread::Get()->Send(message);
 }
 
 #if defined(OS_MACOSX) || defined(OS_ANDROID)
 void RenderFrameImpl::DidHideExternalPopupMenu() {
   // We need to clear external_popup_menu_ as soon as ExternalPopupMenu::close
   // is called. Otherwise, createExternalPopupMenu() for new popup will fail.
   external_popup_menu_.reset();
 }
@@ skipping 133 matching lines @@
   // Can be NULL in tests.
   if (render_thread_impl)
     render_thread_impl->GetRendererScheduler()->OnNavigationStarted();
   DCHECK(!IsBrowserSideNavigationEnabled());
   TRACE_EVENT2("navigation", "RenderFrameImpl::OnNavigate", "id", routing_id_,
                "url", common_params.url.possibly_invalid_spec());
   NavigateInternal(common_params, start_params, request_params,
                    scoped_ptr<StreamOverrideParameters>());
 }
 
-void RenderFrameImpl::NavigateToSwappedOutURL() {
-  // We use loadRequest instead of loadHTMLString because the former commits
-  // synchronously.  Otherwise a new navigation can interrupt the navigation
-  // to kSwappedOutURL. If that happens to be to the page we had been
-  // showing, then WebKit will never send a commit and we'll be left spinning.
-  // Set the is_swapped_out_ bit to true, so IPC filtering is in effect and
-  // the navigation to swappedout:// is not announced to the browser side.
-  is_swapped_out_ = true;
-  GURL swappedOutURL(kSwappedOutURL);
-  WebURLRequest request(swappedOutURL);
-  frame_->loadRequest(request);
-}
-
 void RenderFrameImpl::BindServiceRegistry(
     mojo::shell::mojom::InterfaceProviderRequest services,
     mojo::shell::mojom::InterfaceProviderPtr exposed_services) {
   service_registry_.Bind(std::move(services));
   service_registry_.BindRemoteServiceProvider(std::move(exposed_services));
 }
 
 ManifestManager* RenderFrameImpl::manifest_manager() {
   return manifest_manager_;
 }
@@ skipping 22 matching lines @@
 void RenderFrameImpl::OnSwapOut(
     int proxy_routing_id,
     bool is_loading,
     const FrameReplicationState& replicated_frame_state) {
   TRACE_EVENT1("navigation", "RenderFrameImpl::OnSwapOut", "id", routing_id_);
   RenderFrameProxy* proxy = NULL;
 
   // This codepath should only be hit for subframes when in --site-per-process.
   CHECK(is_main_frame_ || SiteIsolationPolicy::AreCrossProcessFramesPossible());
 
-  // Only run unload if we're not swapped out yet, but send the ack either way.
-  if (!is_swapped_out_) {
-    // Swap this RenderFrame out so the frame can navigate to a page rendered by
-    // a different process.  This involves running the unload handler and
-    // clearing the page.  We also allow this process to exit if there are no
-    // other active RenderFrames in it.
+  // Swap this RenderFrame out so the frame can navigate to a page rendered by
+  // a different process.  This involves running the unload handler and
+  // clearing the page.  We also allow this process to exit if there are no
+  // other active RenderFrames in it.
 
-    // Send an UpdateState message before we get swapped out.
-    if (SiteIsolationPolicy::UseSubframeNavigationEntries())
-      SendUpdateState();
-    else
-      render_view_->SendUpdateState();
+  // Send an UpdateState message before we get deleted.
+  if (SiteIsolationPolicy::UseSubframeNavigationEntries())
+    SendUpdateState();
+  else
+    render_view_->SendUpdateState();
 
-    // If we need a proxy to replace this, create it now so its routing id is
-    // registered for receiving IPC messages.
-    if (proxy_routing_id != MSG_ROUTING_NONE) {
-      proxy = RenderFrameProxy::CreateProxyToReplaceFrame(
-          this, proxy_routing_id, replicated_frame_state.scope);
-    }
+  // If we need a proxy to replace this, create it now so its routing id is
+  // registered for receiving IPC messages.
+  if (proxy_routing_id != MSG_ROUTING_NONE) {
+    proxy = RenderFrameProxy::CreateProxyToReplaceFrame(
+        this, proxy_routing_id, replicated_frame_state.scope);
+  }
 
-    // Synchronously run the unload handler before sending the ACK.
-    // TODO(creis): Call dispatchUnloadEvent unconditionally here to support
-    // unload on subframes as well.
-    if (is_main_frame_)
-      frame_->dispatchUnloadEvent();
+  // Synchronously run the unload handler before sending the ACK.
+  // TODO(creis): Call dispatchUnloadEvent unconditionally here to support
+  // unload on subframes as well.
+  if (is_main_frame_)
+    frame_->dispatchUnloadEvent();
 
-    // Swap out and stop sending any IPC messages that are not ACKs.
-    if (is_main_frame_)
-      render_view_->SetSwappedOut(true);
-    is_swapped_out_ = true;
+  // Swap out and stop sending any IPC messages that are not ACKs.
+  if (is_main_frame_)
+    render_view_->SetSwappedOut(true);
 
-    // Set the proxy here, since OnStop() below could cause an onload event
-    // handler to execute, which could trigger code such as
-    // willCheckAndDispatchMessageEvent() that needs the proxy.
-    if (proxy)
-      set_render_frame_proxy(proxy);
+  // Set the proxy here, since OnStop() below could cause an onload event
+  // handler to execute, which could trigger code such as
+  // willCheckAndDispatchMessageEvent() that needs the proxy.
+  if (proxy)
+    set_render_frame_proxy(proxy);
 
-    // Transfer settings such as initial drawing parameters to the remote frame,
-    // if one is created, that will replace this frame.
-    if (!is_main_frame_ && proxy)
-      proxy->web_frame()->initializeFromFrame(frame_);
+  // Transfer settings such as initial drawing parameters to the remote frame,
+  // if one is created, that will replace this frame.
+  if (!is_main_frame_ && proxy)
+    proxy->web_frame()->initializeFromFrame(frame_);
 
-    // Let WebKit know that this view is hidden so it can drop resources and
-    // stop compositing.
-    // TODO(creis): Support this for subframes as well.
-    if (is_main_frame_) {
-      render_view_->webview()->setVisibilityState(
-          blink::WebPageVisibilityStateHidden, false);
-    }
+  // Let WebKit know that this view is hidden so it can drop resources and
+  // stop compositing.
+  // TODO(creis): Support this for subframes as well.
+  if (is_main_frame_) {
+    render_view_->webview()->setVisibilityState(
+        blink::WebPageVisibilityStateHidden, false);
   }
 
   // It is now safe to show modal dialogs again.
   // TODO(creis): Deal with modal dialogs from subframes.
   if (is_main_frame_)
     render_view_->suppress_dialogs_until_swap_out_ = false;
 
   Send(new FrameHostMsg_SwapOut_ACK(routing_id_));
 
   RenderViewImpl* render_view = render_view_.get();
@@ skipping 1005 matching lines @@
   params.parent_routing_id = routing_id_;
   params.scope = scope;
   params.frame_name = base::UTF16ToUTF8(base::StringPiece16(name));
   params.frame_unique_name =
       base::UTF16ToUTF8(base::StringPiece16(unique_name));
   params.sandbox_flags = sandbox_flags;
   params.frame_owner_properties = frame_owner_properties;
   Send(new FrameHostMsg_CreateChildFrame(params, &child_routing_id));
 
   // Allocation of routing id failed, so we can't create a child frame. This can
-  // happen if this RenderFrameImpl's IPCs are being filtered when in swapped
-  // out state or synchronous IPC message above has failed.
+  // happen if the synchronous IPC message above has failed.
   if (child_routing_id == MSG_ROUTING_NONE) {
     NOTREACHED() << "Failed to allocate routing id for child frame.";
     return nullptr;
   }
 
   // This method is always called by local frames, never remote frames.
 
   // Tracing analysis uses this to find main frames when this value is
   // MSG_ROUTING_NONE, and build the frame tree otherwise.
   TRACE_EVENT2("navigation", "RenderFrameImpl::createChildFrame",
                "id", routing_id_,
                "child", child_routing_id);
 
   // Create the RenderFrame and WebLocalFrame, linking the two.
   RenderFrameImpl* child_render_frame = RenderFrameImpl::Create(
       render_view_.get(), child_routing_id);
   blink::WebLocalFrame* web_frame =
       WebLocalFrame::create(scope, child_render_frame);
   child_render_frame->BindToWebFrame(web_frame);
 
   // Add the frame to the frame tree and initialize it.
   parent->appendChild(web_frame);
   child_render_frame->in_frame_tree_ = true;
   child_render_frame->Initialize();
 
   return web_frame;
 }
 
 void RenderFrameImpl::didChangeOpener(blink::WebFrame* opener) {
-  // Only active frames are able to disown their opener.
-  if (!opener && is_swapped_out_)
-    return;
-
   // Only a local frame should be able to update another frame's opener.
   DCHECK(!opener || opener->isWebLocalFrame());
 
   int opener_routing_id = opener ?
       RenderFrameImpl::FromWebFrame(opener->toWebLocalFrame())->GetRoutingID() :
       MSG_ROUTING_NONE;
   Send(new FrameHostMsg_DidChangeOpener(routing_id_, opener_routing_id));
 }
 
 void RenderFrameImpl::frameDetached(blink::WebFrame* frame, DetachType type) {
@@ skipping 332 matching lines @@
   // In fast/loader/stop-provisional-loads.html, we abort the load before this
   // callback is invoked.
   if (!ds)
     return;
 
   TRACE_EVENT2("navigation,benchmark",
                "RenderFrameImpl::didStartProvisionalLoad", "id", routing_id_,
                "url", ds->request().url().string().utf8());
   DocumentState* document_state = DocumentState::FromDataSource(ds);
 
-  // We should only navigate to swappedout:// when is_swapped_out_ is true.
-  CHECK(ds->request().url() != GURL(kSwappedOutURL) || is_swapped_out_)
-      << "Heard swappedout:// when not swapped out.";
+  // We should never navigate to swappedout://.
+  CHECK(ds->request().url() != GURL(kSwappedOutURL)) << "Heard swappedout://.";
 
   // Update the request time if WebKit has better knowledge of it.
   if (document_state->request_time().is_null() &&
           triggering_event_time != 0.0) {
     document_state->set_request_time(Time::FromDoubleT(triggering_event_time));
   }
 
   // Start time is only set after request time.
   document_state->set_start_load_time(Time::Now());
 
@@ skipping 449 matching lines @@
       TRACE_EVENT_INSTANT0("WebCore,benchmark", "LoadFinished",
                            TRACE_EVENT_SCOPE_PROCESS);
     }
     document_state->set_finish_load_time(Time::Now());
   }
 
   FOR_EACH_OBSERVER(RenderViewObserver, render_view_->observers(),
                     DidFinishLoad(frame));
   FOR_EACH_OBSERVER(RenderFrameObserver, observers_, DidFinishLoad());
 
-  // Don't send this message while the frame is swapped out.
-  if (is_swapped_out())
-    return;
-
   Send(new FrameHostMsg_DidFinishLoad(routing_id_,
                                       ds->request().url()));
 }
 
 void RenderFrameImpl::didNavigateWithinPage(blink::WebLocalFrame* frame,
     const blink::WebHistoryItem& item,
     blink::WebHistoryCommitType commit_type) {
   TRACE_EVENT1("navigation", "RenderFrameImpl::didNavigateWithinPage",
                "id", routing_id_);
   DCHECK_EQ(frame_, frame);
@@ skipping 97 matching lines @@
                                  message,
                                  default_value,
                                  frame_->document().url(),
                                  &result);
   if (ok)
     actual_value->assign(result);
   return ok;
 }
 
 bool RenderFrameImpl::runModalBeforeUnloadDialog(bool is_reload) {
-  // If we are swapping out, we have already run the beforeunload handler.
-  // TODO(creis): Fix OnSwapOut to clear the frame without running beforeunload
-  // at all, to avoid running it twice.
-  if (is_swapped_out_)
-    return true;
-
   // Don't allow further dialogs if we are waiting to swap out, since the
   // PageGroupLoadDeferrer in our stack prevents it.
   if (render_view()->suppress_dialogs_until_swap_out_)
     return false;
 
   bool success = false;
   // This is an ignored return value, but is included so we can accept the same
   // response as RunJavaScriptMessage.
   base::string16 ignored_result;
   render_view()->SendAndRunNestedMessageLoop(
@@ skipping 487 matching lines @@
   return midi_dispatcher_;
 }
 
 bool RenderFrameImpl::willCheckAndDispatchMessageEvent(
     blink::WebLocalFrame* source_frame,
     blink::WebFrame* target_frame,
     blink::WebSecurityOrigin target_origin,
     blink::WebDOMMessageEvent event) {
   DCHECK(!frame_ || frame_ == target_frame);
 
-  // Currently, a postMessage that targets a cross-process frame can be plumbed
-  // either through this function or RenderFrameProxy::postMessageEvent. This
-  // function is used when the target cross-process frame is a top-level frame
-  // which has been swapped out.  In that case, the corresponding WebLocalFrame
-  // currently remains in the frame tree even in site-per-process mode (see
-  // OnSwapOut). RenderFrameProxy::postMessageEvent is used in
-  // --site-per-process mode for all other cases.
-  //
   // TODO(alexmos, nasko): When swapped-out:// disappears, this should be
   // cleaned up so that RenderFrameProxy::postMessageEvent is the only path for
   // cross-process postMessages.
-  if (!is_swapped_out_)
-    return false;
 
   // It is possible to get here on a swapped-out frame without a
   // |render_frame_proxy_|. This happens when:
   // - This process only has one active RenderView and is about to go away
   //   (e.g., due to cross-process navigation).
   // - The top frame has a subframe with an unload handler.
   // - The subframe sends a postMessage to the top-level frame in its unload
   //   handler.
   // See https://crbug.com/475651 for details.  We return false here, since we
   // don't want to deliver the message to the new process in this case.
@@ skipping 285 matching lines @@
   WebURLResponseExtraDataImpl* extra_data = GetExtraDataFromResponse(response);
   if (extra_data)
     params.was_fetched_via_proxy = extra_data->was_fetched_via_proxy();
   params.was_within_same_page = navigation_state->WasWithinSamePage();
   params.security_info = response.securityInfo();
 
   // Set the origin of the frame.  This will be replicated to the corresponding
   // RenderFrameProxies in other processes.
   // TODO(alexmos): Origins for URLs with non-standard schemes are excluded due
   // to https://crbug.com/439608 and will be replicated as unique origins.
-  if (!is_swapped_out_) {
-    std::string scheme =
-        frame->document().getSecurityOrigin().protocol().utf8();
-    if (url::IsStandard(scheme.c_str(),
-                        url::Component(0, static_cast<int>(scheme.length())))) {
-      params.origin = frame->document().getSecurityOrigin();
-    }
+  std::string scheme = frame->document().getSecurityOrigin().protocol().utf8();
+  if (url::IsStandard(scheme.c_str(),

[alexmos, 2016/03/17 21:41:27]

This reminded me to go clean this up, since url::Origin now handles such things
gracefully.  I'm going to put up a short CL for this and rebase on this once you
land it.

[nasko, 2016/03/17 23:19:11]

Acknowledged.

+                      url::Component(0, static_cast<int>(scheme.length())))) {
+    params.origin = frame->document().getSecurityOrigin();
   }
 
   params.should_enforce_strict_mixed_content_checking =
       frame->shouldEnforceStrictMixedContentChecking();
 
   params.has_potentially_trustworthy_unique_origin =
       frame->document().getSecurityOrigin().isUnique() &&
       frame->document().getSecurityOrigin().isPotentiallyTrustworthy();
 
   // Set the URL to be displayed in the browser UI to the user.
   params.url = GetLoadingUrl();
-  DCHECK(!is_swapped_out_ || params.url == GURL(kSwappedOutURL));
-
   if (frame->document().baseURL() != params.url)
     params.base_url = frame->document().baseURL();
 
   GetRedirectChain(ds, &params.redirects);
   params.should_update_history =
       !ds->hasUnreachableURL() && response.httpStatusCode() != 404;
 
   params.searchable_form_url = internal_data->searchable_form_url();
   params.searchable_form_encoding = internal_data->searchable_form_encoding();
 
@@ skipping 101 matching lines @@
     // process.
     params.original_request_url = GetOriginalRequestURL(ds);
 
     params.history_list_was_cleared =
         navigation_state->request_params().should_clear_history_list;
 
     params.report_type = static_cast<FrameMsg_UILoadMetricsReportType::Value>(
         frame->dataSource()->request().inputPerfMetricReportPolicy());
     params.ui_timestamp = base::TimeTicks() + base::TimeDelta::FromSecondsD(
         frame->dataSource()->request().uiStartTime());
-
-    // This message needs to be sent before any of allowScripts(),
-    // allowImages(), allowPlugins() is called for the new page, so that when
-    // these functions send a ViewHostMsg_ContentBlocked message, it arrives
-    // after the FrameHostMsg_DidCommitProvisionalLoad message.
-    Send(new FrameHostMsg_DidCommitProvisionalLoad(routing_id_, params));
   } else {
     // Subframe navigation: the type depends on whether this navigation
     // generated a new session history entry. When they do generate a session
     // history entry, it means the user initiated the navigation and we should
     // mark it as such.
     if (commit_type == blink::WebStandardCommit)
       params.transition = ui::PAGE_TRANSITION_MANUAL_SUBFRAME;
     else
       params.transition = ui::PAGE_TRANSITION_AUTO_SUBFRAME;
 
     DCHECK(!navigation_state->request_params().should_clear_history_list);
     params.history_list_was_cleared = false;
     params.report_type = FrameMsg_UILoadMetricsReportType::NO_REPORT;
+  }
 
-    // Don't send this message while the subframe is swapped out.
-    if (!is_swapped_out())
-      Send(new FrameHostMsg_DidCommitProvisionalLoad(routing_id_, params));
-  }
+  // This message needs to be sent before any of allowScripts(),
+  // allowImages(), allowPlugins() is called for the new page, so that when
+  // these functions send a ViewHostMsg_ContentBlocked message, it arrives
+  // after the FrameHostMsg_DidCommitProvisionalLoad message.
+  Send(new FrameHostMsg_DidCommitProvisionalLoad(routing_id_, params));
 
   // If we end up reusing this WebRequest (for example, due to a #ref click),
   // we don't want the transition type to persist.  Just clear it.
   navigation_state->set_transition_type(ui::PAGE_TRANSITION_LINK);
 }
 
 void RenderFrameImpl::didStartLoading(bool to_different_document) {
   TRACE_EVENT1("navigation", "RenderFrameImpl::didStartLoading",
                "id", routing_id_);
   render_view_->FrameDidStartLoading(frame_);
@@ skipping 132 matching lines @@
           this, is_content_initiated, render_view_->opener_id_, frame_,
           info.urlRequest, info.navigationType, info.defaultPolicy,
           is_redirect)) {
     return blink::WebNavigationPolicyIgnore;
   }
 #endif
 
   Referrer referrer(
       RenderViewImpl::GetReferrerFromRequest(frame_, info.urlRequest));
 
-  // TODO(nick): Is consulting |is_main_frame| here correct?
-  if (is_main_frame_ && is_swapped_out_) {
-    if (info.urlRequest.url() != GURL(kSwappedOutURL)) {
-      // Targeted links may try to navigate a swapped out frame.  Allow the
-      // browser process to navigate the tab instead.  Note that it is also
-      // possible for non-targeted navigations (from this view) to arrive
-      // here just after we are swapped out.  It's ok to send them to the
-      // browser, as long as they're for the top level frame.
-      // TODO(creis): Ensure this supports targeted form submissions when
-      // fixing http://crbug.com/101395.
-      if (frame_->parent() == NULL) {
-        OpenURL(info.urlRequest.url(), referrer, info.defaultPolicy,
-                info.replacesCurrentHistoryItem, false);
-        return blink::WebNavigationPolicyIgnore;  // Suppress the load here.
-      }
-
-      // We should otherwise ignore in-process iframe navigations, if they
-      // arrive just after we are swapped out.
-      return blink::WebNavigationPolicyIgnore;
-    }
-
-    // Allow kSwappedOutURL to complete.
-    return info.defaultPolicy;
-  }
-
   // Webkit is asking whether to navigate to a new URL.
   // This is fine normally, except if we're showing UI from one security
   // context and they're trying to navigate to a different context.
   const GURL& url = info.urlRequest.url();
 
   // If the browser is interested, then give it a chance to look at the request.
   if (is_content_initiated && IsTopLevelNavigation(frame_) &&
       render_view_->renderer_preferences_
           .browser_handles_all_top_level_requests) {
     OpenURL(url, referrer, info.defaultPolicy, info.replacesCurrentHistoryItem,
@@ skipping 847 matching lines @@
       RenderViewObserver, render_view_->observers_, Navigate(url));
 
   render_view_->history_list_offset_ =
       request_params.current_history_list_offset;
   render_view_->history_list_length_ =
       request_params.current_history_list_length;
   if (request_params.should_clear_history_list) {
     CHECK_EQ(-1, render_view_->history_list_offset_);
     CHECK_EQ(0, render_view_->history_list_length_);
   }
-
-  if (!is_swapped_out_ || frame_->parent())
-    return;
-
-  // This is a swapped out main frame, so swap the renderer back in.
-  // We marked the view as hidden when swapping the view out, so be sure to
-  // reset the visibility state before navigating to the new URL.
-  render_view_->webview()->setVisibilityState(
-      render_view_->visibilityState(), false);
-
-  // If this is an attempt to reload while we are swapped out, we should not
-  // reload swappedout://, but the previous page, which is stored in
-  // params.state.  Setting is_reload to false will treat this like a back
-  // navigation to accomplish that.
-  *is_reload = false;
-  *cache_policy = WebURLRequest::ReloadIgnoringCacheData;
-
-  // We refresh timezone when a view is swapped in since timezone
-  // can get out of sync when the system timezone is updated while
-  // the view is swapped out.
-  RenderThreadImpl::NotifyTimezoneChange();
-
-  render_view_->SetSwappedOut(false);
-  is_swapped_out_ = false;
-  return;
 }
 
 void RenderFrameImpl::BeginNavigation(blink::WebURLRequest* request,
                                       bool should_replace_current_entry,
                                       bool is_client_redirect) {
   CHECK(IsBrowserSideNavigationEnabled());
   DCHECK(request);
   // TODO(clamy): Execute the beforeunload event.
 
   // Note: At this stage, the goal is to apply all the modifications the
@@ skipping 426 matching lines @@
                                     int match_count,
                                     int ordinal,
                                     const WebRect& selection_rect,
                                     bool final_status_update) {
   Send(new FrameHostMsg_Find_Reply(routing_id_, request_id, match_count,
                                    selection_rect, ordinal,
                                    final_status_update));
 }
 
 }  // namespace content