Rename |tab_contents_id| to |render_view_routing_id|.

chrome/browser/external_protocol/external_protocol_handler.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 "chrome/browser/external_protocol/external_protocol_handler.h"
 
 #include <stddef.h>
 
 #include <set>
 
@@ skipping 62 matching lines @@
   } else {
     delegate->RunExternalProtocolDialog(
         url, render_process_host_id, routing_id, page_transition,
         has_user_gesture);
   }
 }
 
 void LaunchUrlWithoutSecurityCheckWithDelegate(
     const GURL& url,
     int render_process_host_id,
-    int tab_contents_id,
+    int render_view_routing_id,
     ExternalProtocolHandler::Delegate* delegate) {
-  content::WebContents* web_contents =
-      tab_util::GetWebContentsByID(render_process_host_id, tab_contents_id);
+  content::WebContents* web_contents = tab_util::GetWebContentsByID(
+      render_process_host_id, render_view_routing_id);
 
   if (!delegate) {
     ExternalProtocolHandler::LaunchUrlWithoutSecurityCheck(url, web_contents);
   } else {
     delegate->LaunchUrlWithoutSecurityCheck(url, web_contents);
   }
 }
 
 // When we are about to launch a URL with the default OS level application, we
 // check if the external application will be us. If it is we just ignore the
 // request.
 void OnDefaultProtocolClientWorkerFinished(
     const GURL& escaped_url,
     int render_process_host_id,
-    int tab_contents_id,
+    int render_view_routing_id,
     bool prompt_user,
     ui::PageTransition page_transition,
     bool has_user_gesture,
     ExternalProtocolHandler::Delegate* delegate,
     shell_integration::DefaultWebClientState state) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (delegate)
     delegate->FinishedProcessingCheck();
 
   if (state == shell_integration::IS_DEFAULT) {
     if (delegate)
       delegate->BlockRequest();
     return;
   }
 
   // If we get here, either we are not the default or we cannot work out
   // what the default is, so we proceed.
   if (prompt_user) {
     // Ask the user if they want to allow the protocol. This will call
     // LaunchUrlWithoutSecurityCheck if the user decides to accept the
     // protocol.
-    RunExternalProtocolDialogWithDelegate(escaped_url, render_process_host_id,
-                                          tab_contents_id, page_transition,
-                                          has_user_gesture, delegate);
+    RunExternalProtocolDialogWithDelegate(
+        escaped_url, render_process_host_id, render_view_routing_id,
+        page_transition, has_user_gesture, delegate);
     return;
   }
 
   LaunchUrlWithoutSecurityCheckWithDelegate(escaped_url, render_process_host_id,
-                                            tab_contents_id, delegate);
+                                            render_view_routing_id, delegate);
 }
 
 }  // namespace
 
 // static
 ExternalProtocolHandler::BlockState ExternalProtocolHandler::GetBlockState(
     const std::string& scheme) {
   // If we are being carpet bombed, block the request.
   if (!g_accept_requests)
     return BLOCK;
@@ skipping 38 matching lines @@
     } else {
       update_excluded_schemas->SetBoolean(scheme, (state == BLOCK));
     }
   }
 }
 
 // static
 void ExternalProtocolHandler::LaunchUrlWithDelegate(
     const GURL& url,
     int render_process_host_id,
-    int tab_contents_id,
+    int render_view_routing_id,
     ui::PageTransition page_transition,
     bool has_user_gesture,
     Delegate* delegate) {
   DCHECK(base::MessageLoopForUI::IsCurrent());
 
   // Escape the input scheme to be sure that the command does not
   // have parameters unexpected by the external program.
   std::string escaped_url_string = net::EscapeExternalHandlerValue(url.spec());
   GURL escaped_url(escaped_url_string);
   BlockState block_state =
       GetBlockStateWithDelegate(escaped_url.scheme(), delegate);
   if (block_state == BLOCK) {
     if (delegate)
       delegate->BlockRequest();
     return;
   }
 
   g_accept_requests = false;
 
   // The worker creates tasks with references to itself and puts them into
   // message loops.
   shell_integration::DefaultWebClientWorkerCallback callback = base::Bind(
       &OnDefaultProtocolClientWorkerFinished, url, render_process_host_id,
-      tab_contents_id, block_state == UNKNOWN, page_transition,
+      render_view_routing_id, block_state == UNKNOWN, page_transition,
       has_user_gesture, delegate);
 
   // Start the check process running. This will send tasks to the FILE thread
   // and when the answer is known will send the result back to
   // OnDefaultProtocolClientWorkerFinished().
   CreateShellWorker(callback, escaped_url.scheme(), delegate)
       ->StartCheckIsDefault();
 }
 
 // static
@@ skipping 69 matching lines @@
 // static
 void ExternalProtocolHandler::RecordMetrics(bool selected) {
   UMA_HISTOGRAM_BOOLEAN("BrowserDialogs.ExternalProtocol.RememberCheckbox",
                         selected);
 }
 
 // static
 void ExternalProtocolHandler::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterDictionaryPref(prefs::kExcludedSchemes);
 }