[Contextual Search] Trigger the translation one-box.

chrome/browser/android/contextualsearch/contextual_search_delegate.cc

 // Copyright 2015 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/android/contextualsearch/contextual_search_delegate.h"
 
 #include <algorithm>
 
 #include "base/base64.h"
 #include "base/command_line.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
+#include "chrome/browser/android/contextualsearch/resolved_search_term.h"
 #include "chrome/browser/android/proto/client_discourse_context.pb.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
+#include "chrome/browser/translate/translate_service.h"
 #include "components/search_engines/template_url_service.h"
 #include "components/variations/net/variations_http_header_provider.h"
 #include "components/variations/variations_associated_data.h"
 #include "content/public/browser/android/content_view_core.h"
 #include "content/public/browser/web_contents.h"
 #include "net/base/escape.h"
 #include "net/url_request/url_fetcher.h"
 #include "url/gurl.h"
 
 using content::ContentViewCore;
 
 namespace {
 
 const char kContextualSearchFieldTrialName[] = "ContextualSearch";
 const char kContextualSearchSurroundingSizeParamName[] = "surrounding_size";
 const char kContextualSearchIcingSurroundingSizeParamName[] =
     "icing_surrounding_size";
 const char kContextualSearchResolverURLParamName[] = "resolver_url";
 const char kContextualSearchDoNotSendURLParamName[] = "do_not_send_url";
 const char kContextualSearchResponseDisplayTextParam[] = "display_text";
 const char kContextualSearchResponseSelectedTextParam[] = "selected_text";
 const char kContextualSearchResponseSearchTermParam[] = "search_term";
+const char kContextualSearchResponseLanguageParam[] = "lang";
 const char kContextualSearchResponseResolvedTermParam[] = "resolved_term";
 const char kContextualSearchPreventPreload[] = "prevent_preload";
 const char kContextualSearchMentions[] = "mentions";
 const char kContextualSearchServerEndpoint[] = "_/contextualsearch?";
 const int kContextualSearchRequestVersion = 2;
 const char kContextualSearchResolverUrl[] =
     "contextual-search-resolver-url";
 // The default size of the content surrounding the selection to gather, allowing
 // room for other parameters.
 const int kContextualSearchDefaultContentSize = 1536;
@@ skipping 89 matching lines @@
   DCHECK(source == search_term_fetcher_.get());
   int response_code = source->GetResponseCode();
   std::string search_term;
   std::string display_text;
   std::string alternate_term;
   std::string prevent_preload;
   int mention_start = 0;
   int mention_end = 0;
   int start_adjust = 0;
   int end_adjust = 0;
+  std::string language;
+  std::string target_language;
 
   if (source->GetStatus().is_success() && response_code == 200) {
     std::string response;
     bool has_string_response = source->GetResponseAsString(&response);
     DCHECK(has_string_response);
     if (has_string_response) {
-      DecodeSearchTermsFromJsonResponse(response, &search_term, &display_text,
-                                        &alternate_term, &prevent_preload,
-                                        &mention_start, &mention_end);
+      DecodeSearchTermFromJsonResponse(response, &search_term, &display_text,
+                                       &alternate_term, &prevent_preload,
+                                       &mention_start, &mention_end, &language);
       if (mention_start != 0 || mention_end != 0) {
         // Sanity check that our selection is non-zero and it is less than
         // 100 characters as that would make contextual search bar hide.
         // We also check that there is at least one character overlap between
         // the new and old selection.
         if (mention_start >= mention_end
             || (mention_end - mention_start) > kContextualSearchMaxSelection
             || mention_end <= context_->start_offset
             || mention_start >= context_->end_offset) {
           start_adjust = 0;
           end_adjust = 0;
         } else {
           start_adjust = mention_start - context_->start_offset;
           end_adjust = mention_end - context_->end_offset;
         }
       }
     }
   }
   bool is_invalid = response_code == net::URLFetcher::RESPONSE_CODE_INVALID;
-  search_term_callback_.Run(
+  ResolvedSearchTerm resolved_search_term(
       is_invalid, response_code, search_term, display_text, alternate_term,
-      prevent_preload == kDoPreventPreloadValue, start_adjust, end_adjust);
+      prevent_preload == kDoPreventPreloadValue, start_adjust, end_adjust,
+      language);
+  search_term_callback_.Run(resolved_search_term);
 
   // The ContextualSearchContext is consumed once the request has completed.
   context_.reset();
 }
 
 // TODO(jeremycho): Remove selected_text and base_page_url CGI parameters.
 GURL ContextualSearchDelegate::BuildRequestUrl() {
   // TODO(jeremycho): Confirm this is the right way to handle TemplateURL fails.
   if (!template_url_service_ ||
       !template_url_service_->GetDefaultSearchProvider()) {
@@ skipping 225 matching lines @@
   if (service == NULL || !service->CanSyncStart() ||
       !sync_prefs.GetPreferredDataTypes(syncer::UserTypes())
            .Has(syncer::PROXY_TABS) ||
       !service->GetActiveDataTypes().Has(syncer::HISTORY_DELETE_DIRECTIVES)) {
     return false;
   }
 
   return true;
 }
 
+// Gets the target language from the user's profile, and caches
+// if for subsequent requests.
+std::string ContextualSearchDelegate::GetTargetLanguage() {
+  if (target_language_.empty()) {
+    Profile* profile = ProfileManager::GetActiveUserProfile();
+    PrefService* prefs = profile->GetPrefs();
+    target_language_ = TranslateService::GetTargetLanguage(prefs);
+    DCHECK(!target_language_.empty());
+  }
+  return target_language_;

[pedro (no code reviews), 2015/09/23 18:33:55]

We should probably get a list of languages, and not just a single one. I would
hate loosing Contextual Search just because I'm reading portuguese pages and
Google thinks that I need to translate words, instead of getting actual results.
That would make Contextual Search much less useful in portuguese for me
(specially if we use the "translate" string as a trigger).

[Donn Denman, 2015/10/09 22:08:23]

Done.

+}
+
 // Decodes the given response from the search term resolution request and sets
 // the value of the given parameters.
-void ContextualSearchDelegate::DecodeSearchTermsFromJsonResponse(
+void ContextualSearchDelegate::DecodeSearchTermFromJsonResponse(
     const std::string& response,
     std::string* search_term,
     std::string* display_text,
     std::string* alternate_term,
     std::string* prevent_preload,
     int* mention_start,
-    int* mention_end) {
+    int* mention_end,
+    std::string* lang) {
   bool contains_xssi_escape = response.find(kXssiEscape) == 0;
   const std::string& proper_json =
       contains_xssi_escape ? response.substr(strlen(kXssiEscape)) : response;
   JSONStringValueDeserializer deserializer(proper_json);
   scoped_ptr<base::Value> root(deserializer.Deserialize(NULL, NULL));
 
   if (root.get() != NULL && root->IsType(base::Value::TYPE_DICTIONARY)) {
     base::DictionaryValue* dict =
         static_cast<base::DictionaryValue*>(root.get());
     dict->GetString(kContextualSearchPreventPreload, prevent_preload);
     dict->GetString(kContextualSearchResponseSearchTermParam, search_term);
+    dict->GetString(kContextualSearchResponseLanguageParam, lang);
     // For the display_text, if not present fall back to the "search_term".
     if (!dict->GetString(kContextualSearchResponseDisplayTextParam,
                          display_text)) {
       *display_text = *search_term;
     }
     // Extract mentions for selection expansion.
     base::ListValue* mentions_list;
     dict->GetList(kContextualSearchMentions, &mentions_list);
     if (mentions_list != NULL && mentions_list->GetSize() >= 2)
       ExtractMentionsStartEnd(*mentions_list, mention_start, mention_end);
@@ skipping 75 matching lines @@
     end_offset -= trim;
   }
   if (result_text.length() > end_offset + padding_each_side_pinned) {
     // Trim the end.
     result_text = result_text.substr(0, end_offset + padding_each_side_pinned);
   }
   *start = start_offset;
   *end = end_offset;
   return result_text;
 }