Consolidate search terms extraction and Instant process determination.

chrome/browser/chrome_content_browser_client.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/chrome_content_browser_client.h"
 
 #include <set>
 #include <utility>
 #include <vector>
 
@@ skipping 45 matching lines @@
 #include "chrome/browser/prerender/prerender_message_filter.h"
 #include "chrome/browser/prerender/prerender_tracker.h"
 #include "chrome/browser/printing/printing_message_filter.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_io_data.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/renderer_host/chrome_render_message_filter.h"
 #include "chrome/browser/renderer_host/chrome_render_view_host_observer.h"
 #include "chrome/browser/renderer_host/pepper/chrome_browser_pepper_host_factory.h"
 #include "chrome/browser/search_engines/search_provider_install_state_message_filter.h"
-#include "chrome/browser/search_engines/template_url_service.h"
-#include "chrome/browser/search_engines/template_url_service_factory.h"
 #include "chrome/browser/speech/chrome_speech_recognition_manager_delegate.h"
 #include "chrome/browser/spellchecker/spellcheck_message_filter.h"
 #include "chrome/browser/ssl/ssl_add_certificate.h"
 #include "chrome/browser/ssl/ssl_blocking_page.h"
 #include "chrome/browser/ssl/ssl_tab_helper.h"
 #include "chrome/browser/tab_contents/tab_util.h"
 #include "chrome/browser/toolkit_extra_parts.h"
 #include "chrome/browser/ui/chrome_select_file_policy.h"
+#include "chrome/browser/ui/search/search.h"
 #include "chrome/browser/ui/tab_contents/chrome_web_contents_view_delegate.h"
 #include "chrome/browser/ui/webui/chrome_web_ui_controller_factory.h"
 #include "chrome/browser/user_style_sheet_watcher.h"
 #include "chrome/browser/user_style_sheet_watcher_factory.h"
 #include "chrome/browser/view_type_utils.h"
 #include "chrome/common/child_process_logging.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension.h"
@@ skipping 314 matching lines @@
   if (process_type == switches::kPpapiPluginProcess)
     return PpapiCrashHandlerHostLinux::GetInstance()->GetDeathSignalSocket();
 
   if (process_type == switches::kGpuProcess)
     return GpuCrashHandlerHostLinux::GetInstance()->GetDeathSignalSocket();
 
   return -1;
 }
 #endif  // defined(OS_POSIX) && !defined(OS_MACOSX)
 
-// TODO(dhollowa): http://crbug.com/170390 This test exists in different places
-// in Chrome.  Follow-up to consolidate these various Instant URL checks.
-// Returns true if |url| has the same scheme, host, and path as the instant URL
-// set via --instant-url.
-bool IsForcedInstantURL(const GURL& url) {
-  CommandLine* command_line = CommandLine::ForCurrentProcess();
-  if (command_line->HasSwitch(switches::kInstantURL)) {
-    GURL instant_url(command_line->GetSwitchValueASCII(switches::kInstantURL));
-    if (url.scheme() == instant_url.scheme() &&
-        url.host() == instant_url.host() &&
-        url.path() == instant_url.path()) {
-      return true;
-    }
-  }
-  return false;
-}
-
-// Determines whether the |url| is an Instant url for the default search
-// provider (set for the |profile|).
-// Also returns true if an Instant "effective url" (see below) is passed in.
-bool IsInstantURL(const GURL& url, Profile* profile) {
-  // Handle the command-line URL.
-  if (IsForcedInstantURL(url))
-    return true;
-
-  // A URL of this form has already be determined to be an Instant url,
-  // this is its "effective url".  So trivially return true.
-  if (url.SchemeIs(chrome::kChromeSearchScheme))
-    return true;
-
-  TemplateURLService* template_url_service =
-      TemplateURLServiceFactory::GetForProfile(profile);
-  if (!template_url_service)
-    return false;
-
-  TemplateURL* template_url = template_url_service->GetDefaultSearchProvider();
-  if (!template_url)
-    return false;
-
-  if (template_url->instant_url().empty())
-    return false;
-
-  return template_url->IsInstantURL(url);
-}
-
-// Transforms the input |url| into its "effective url". The returned url
+// Transforms the input |url| into its "effective URL". The returned URL
 // facilitates grouping process-per-site. The |url| is transformed, for
 // example, from
 //
 //   https://www.google.com/search?espv=1&q=tractors
 //
-// to the effective url
+// to the effective URL
 //
 //   chrome-search://www.google.com/search?espv=1&q=tractors
 //
 // Notice the scheme change.
-// If the input is already an effective url then that same url is
-// returned.
-GURL GetEffectiveInstantURL(const GURL& url, Profile* profile) {
-  CHECK(IsInstantURL(url, profile)) << "Error granting Instant access.";
+//
+// If the input is already an effective URL then that same URL is returned.
+GURL GetEffectiveURLForInstant(const GURL& url, Profile* profile) {
+  CHECK(chrome::search::ShouldAssignURLToInstantRenderer(url, profile))
+      << "Error granting Instant access.";
 
   if (url.SchemeIs(chrome::kChromeSearchScheme))
     return url;
 
   GURL effective_url(url);
 
   // Replace the scheme with "chrome-search:".
   url_canon::Replacements<char> replacements;
   std::string search_scheme(chrome::kChromeSearchScheme);
   replacements.SetScheme(search_scheme.data(),
@@ skipping 241 matching lines @@
   GetRendererContentSettingRules(profile->GetHostContentSettingsMap(), &rules);
   host->Send(new ChromeViewMsg_SetContentSettingRules(rules));
 }
 
 GURL ChromeContentBrowserClient::GetEffectiveURL(
     content::BrowserContext* browser_context, const GURL& url) {
   Profile* profile = Profile::FromBrowserContext(browser_context);
   if (!profile)
     return url;
 
-  // If the input |url| is an Instant url, make its effective url distinct from
-  // other urls on the search provider's domain.
-  if (IsInstantURL(url, profile))
-    return GetEffectiveInstantURL(url, profile);
+  // If the input |url| should be assigned to the Instant renderer, make its
+  // effective URL distinct from other URLs on the search provider's domain.
+  if (chrome::search::ShouldAssignURLToInstantRenderer(url, profile))
+    return GetEffectiveURLForInstant(url, profile);
 
   // If the input |url| is part of an installed app, the effective URL is an
   // extension URL with the ID of that extension as the host. This has the
   // effect of grouping apps together in a common SiteInstance.
   ExtensionService* extension_service =
       extensions::ExtensionSystem::Get(profile)->extension_service();
   if (!extension_service)
     return url;
 
   const Extension* extension = extension_service->extensions()->
@@ skipping 15 matching lines @@
     content::BrowserContext* browser_context, const GURL& effective_url) {
   // Non-extension, non-Instant URLs should generally use
   // process-per-site-instance.  Because we expect to use the effective URL,
   // URLs for hosted apps (apart from bookmark apps) should have an extension
   // scheme by now.
 
   Profile* profile = Profile::FromBrowserContext(browser_context);
   if (!profile)
     return false;
 
-  if (IsInstantURL(effective_url, profile))
+  if (chrome::search::ShouldAssignURLToInstantRenderer(effective_url, profile))
     return true;
 
   if (!effective_url.SchemeIs(extensions::kExtensionScheme))
     return false;
 
   ExtensionService* extension_service =
       extensions::ExtensionSystem::Get(profile)->extension_service();
   if (!extension_service)
     return false;
 
@@ skipping 77 matching lines @@
       Profile::FromBrowserContext(process_host->GetBrowserContext());
   // This may be NULL during tests. In that case, just assume any site can
   // share any host.
   if (!profile)
     return true;
 
   InstantService* instant_service =
       InstantServiceFactory::GetForProfile(profile);
   if (instant_service &&
       instant_service->IsInstantProcess(process_host->GetID()))
-    return IsInstantURL(site_url, profile);
+    return chrome::search::ShouldAssignURLToInstantRenderer(site_url, profile);
 
   ExtensionService* service =
       extensions::ExtensionSystem::Get(profile)->extension_service();
   extensions::ProcessMap* process_map = service->process_map();
 
   // Don't allow the Task Manager to share a process with anything else.
   // Otherwise it can affect the renderers it is observing.
   // Note: we could create another RenderProcessHostPrivilege bucket for
   // this to allow multiple chrome://tasks instances to share, but that's
   // a very unlikely case without serious consequences.
@@ skipping 69 matching lines @@
     SiteInstance* site_instance) {
   CHECK(site_instance->HasProcess());
 
   Profile* profile = Profile::FromBrowserContext(
       site_instance->GetBrowserContext());
   if (!profile)
     return;
 
   // Remember the ID of the Instant process to signal the renderer process
   // on startup in |AppendExtraCommandLineSwitches| below.
-  if (IsInstantURL(site_instance->GetSiteURL(), profile)) {
+  if (chrome::search::ShouldAssignURLToInstantRenderer(
+          site_instance->GetSiteURL(), profile)) {
     InstantService* instant_service =
         InstantServiceFactory::GetForProfile(profile);
     if (instant_service)
       instant_service->AddInstantProcess(site_instance->GetProcess()->GetID());
   }
 
   ExtensionService* service =
       extensions::ExtensionSystem::Get(profile)->extension_service();
   if (!service)
     return;
@@ skipping 1120 matching lines @@
     io_thread_application_locale_ = locale;
 }
 
 void ChromeContentBrowserClient::SetApplicationLocaleOnIOThread(
     const std::string& locale) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   io_thread_application_locale_ = locale;
 }
 
 }  // namespace chrome