Merge r1978 to Beta to stop sending queries with username info,...

chrome/browser/autocomplete/search_provider.cc

 // Copyright 2008, Google Inc.
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //    * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //    * Redistributions in binary form must reproduce the above
@@ skipping 155 matching lines @@
       profile_->GetHistoryService(Profile::EXPLICIT_ACCESS);
   history_service->GetMostRecentKeywordSearchTerms(default_provider_.id(),
       input_.text(), static_cast<int>(max_matches()),
       &history_request_consumer_,
       NewCallback(this, &SearchProvider::OnGotMostRecentKeywordSearchTerms));
   history_request_pending_ = true;
 }
 
 void SearchProvider::StartOrStopSuggestQuery(bool minimal_changes,
                                              bool synchronous_only) {
-  // Don't run Suggest when off the record, the engine doesn't support it, or
-  // the user has disabled it.  Also don't query the server for URLs that aren't
-  // http/https/ftp.  Sending things like file: and data: is both a waste of
-  // time and a disclosure of potentially private, local data.
-  if (profile_->IsOffTheRecord() ||
-      !default_provider_.suggestions_url() ||
-      !profile_->GetPrefs()->GetBoolean(prefs::kSearchSuggestEnabled) ||
-      ((input_.type() == AutocompleteInput::URL) &&
-       (input_.scheme() != L"http") && (input_.scheme() != L"https") &&
-       (input_.scheme() != L"ftp"))) {
+  if (!IsQuerySuitableForSuggest()) {
     StopSuggest();
     return;
   }
 
   // For the minimal_changes case, if we finished the previous query and still
   // have its results, or are allowed to keep running it, just do that, rather
   // than starting a new query.
   if (minimal_changes &&
       (have_suggest_results_ || (!done_ && !synchronous_only)))
     return;
 
   // We can't keep running any previous query, so halt it.
   StopSuggest();
 
   // We can't start a new query if we're only allowed synchronous results.
   if (synchronous_only)
     return;
 
   // Kick off a timer that will start the URL fetch if it completes before
   // the user types another character.
   suggest_results_pending_ = true;
   MessageLoop::current()->timer_manager()->ResetTimer(timer_.get());
 }
 
+bool SearchProvider::IsQuerySuitableForSuggest() const {
+  // Don't run Suggest when off the record, the engine doesn't support it, or
+  // the user has disabled it.
+  if (profile_->IsOffTheRecord() ||
+      !default_provider_.suggestions_url() ||
+      !profile_->GetPrefs()->GetBoolean(prefs::kSearchSuggestEnabled))
+    return false;
+
+  // If the input type is URL, we take extra care so that private data in URL
+  // isn't sent to the server.
+  if (input_.type() == AutocompleteInput::URL) {
+    // Don't query the server for URLs that aren't http/https/ftp.  Sending
+    // things like file: and data: is both a waste of time and a disclosure of
+    // potentially private, local data.
+    if ((input_.scheme() != L"http") && (input_.scheme() != L"https") &&
+        (input_.scheme() != L"ftp"))
+      return false;
+
+    // Don't leak private data in URL
+    const url_parse::Parsed& parts = input_.parts();
+
+    // Don't send URLs with usernames, queries or refs.  Some of these are
+    // private, and the Suggest server is unlikely to have any useful results
+    // for any of them.
+    // Password is optional and may be omitted.  Checking username is
+    // sufficient.
+    if (parts.username.is_nonempty() || parts.query.is_nonempty() ||
+        parts.ref.is_nonempty())
+      return false;
+    // Don't send anything for https except hostname and port number.
+    // Hostname and port number are OK because they are visible when TCP
+    // connection is established and the Suggest server may provide some
+    // useful completed URL.
+    if (input_.scheme() == L"https" && parts.path.is_nonempty())
+      return false;
+  }
+
+  return true;
+}
+
 void SearchProvider::StopHistory() {
   history_request_consumer_.CancelAllRequests();
   history_request_pending_ = false;
   history_results_.clear();
   have_history_results_ = false;
 }
 
 void SearchProvider::StopSuggest() {
   suggest_results_pending_ = false;
   MessageLoop::current()->timer_manager()->StopTimer(timer_.get());
@@ skipping 394 matching lines @@
   const size_t after_slashes = std::min(url->length(),
                                         static_cast<size_t>(scheme.end() + 3));
   while ((prefix_len < after_slashes) && ((*url)[prefix_len] == L'/'))
     ++prefix_len;
   if (prefix_len == url->length())
     url->clear();
   else
     url->erase(url->begin(), url->begin() + prefix_len);
   return prefix_len;
 }