Adds selection expansion support for Contextual Search.

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"
@@ skipping 23 matching lines @@
 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 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;
 const int kContextualSearchDefaultIcingSurroundingSize = 400;
 // The maximum length of a URL to build.
 const int kMaxURLSize = 2048;
@@ skipping 81 matching lines @@
 }
 
 void ContextualSearchDelegate::OnURLFetchComplete(
     const net::URLFetcher* source) {
   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;
+  size_t mention_start = 0;
+  size_t mention_end = 0;
+  int start_adjust = 0;
+  int end_adjust = 0;
 
   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);
+                                        &alternate_term, &prevent_preload,
+                                        &mention_start, &mention_end);
+      if (mention_start != 0 || mention_end != 0) {
+        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(
       is_invalid, response_code, search_term, display_text, alternate_term,
-      prevent_preload == kDoPreventPreloadValue);
+      prevent_preload == kDoPreventPreloadValue, start_adjust, end_adjust);
 
   // 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 223 matching lines @@
   return true;
 }
 
 // Decodes the given response from the search term resolution request and sets
 // the value of the given parameters.
 void ContextualSearchDelegate::DecodeSearchTermsFromJsonResponse(
     const std::string& response,
     std::string* search_term,
     std::string* display_text,
     std::string* alternate_term,
-    std::string* prevent_preload) {
+    std::string* prevent_preload,
+    size_t* mention_start,
+    size_t* mention_end) {
   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);
     // 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 seleciton-expansion
+    base::ListValue* mentions_list;

[pedro (no code reviews), 2015/06/25 01:30:28]

Does this represent multiple mentions. If so, are we supposed to only look at
the first mention (as this CL is currently doing)?

+    dict->GetList(kContextualSearchMentions, &mentions_list);
+    if (mentions_list != NULL && mentions_list->GetSize() >= 2)
+      ExtractMentionsStartEnd(*mentions_list, mention_start, mention_end);
     // If either the selected text or the resolved term is not the search term,
     // use it as the alternate term.
     std::string selected_text;
     dict->GetString(kContextualSearchResponseSelectedTextParam, &selected_text);
     if (selected_text != *search_term) {
       *alternate_term = selected_text;
     } else {
       std::string resolved_term;
       dict->GetString(kContextualSearchResponseResolvedTermParam,
                       &resolved_term);
       if (resolved_term != *search_term) {
         *alternate_term = resolved_term;
       }
     }
   }
 }
 
 // Returns the size of the surroundings to be sent to the server for search term
 // resolution.
 int ContextualSearchDelegate::GetSearchTermSurroundingSize() {
   const std::string param_value = variations::GetVariationParamValue(
       kContextualSearchFieldTrialName,
       kContextualSearchSurroundingSizeParamName);
   int param_length;
   if (!param_value.empty() && base::StringToInt(param_value, &param_length))
     return param_length;
   return kContextualSearchDefaultContentSize;
 }
 
+// Extract the Start/End of the mentions in the surrounding text
+// for selection-expansion.
+void ContextualSearchDelegate::ExtractMentionsStartEnd(
+    const base::ListValue& mentions_list,
+    size_t* startResult,
+    size_t* endResult) {
+  int int_value;
+  if (mentions_list.GetInteger(0, &int_value))
+    *startResult = int_value;
+  if (mentions_list.GetInteger(1, &int_value))
+    *endResult = int_value;
+}
+
 // Returns the size of the surroundings to be sent to Icing.
 int ContextualSearchDelegate::GetIcingSurroundingSize() {
   std::string param_string = variations::GetVariationParamValue(
       kContextualSearchFieldTrialName,
       kContextualSearchIcingSurroundingSizeParamName);
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           kContextualSearchIcingSurroundingSizeParamName)) {
     param_string = base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
         kContextualSearchIcingSurroundingSizeParamName);
   }
@@ skipping 23 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;
 }