[Contextual Search] Trigger the translation one-box.

chrome/browser/android/contextualsearch/contextual_search_delegate_unittest.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 "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/android/contextualsearch/contextual_search_context.h"
+#include "chrome/browser/android/contextualsearch/resolved_search_term.h"
 #include "components/search_engines/template_url_service.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::ListValue;
 
 namespace {
 
 const char kSomeSpecificBasePage[] = "http://some.specific.host.name.com";
@@ skipping 20 matching lines @@
         base::Bind(&ContextualSearchDelegateTest::recordIcingSelectionAvailable,
                    base::Unretained(this))));
   }
 
   void TearDown() override {
     fetcher_ = NULL;
     is_invalid_ = true;
     response_code_ = -1;
     search_term_ = "invalid";
     display_text_ = "unknown";
+    language_ = "";
   }
 
   TemplateURLService* CreateTemplateURLService() {
     // Set a default search provider that supports Contextual Search.
     TemplateURLData data;
     data.SetURL("https://foobar.com/url?bar={searchTerms}");
     data.contextual_search_url = "https://foobar.com/_/contextualsearch?"
         "{google:contextualSearchVersion}{google:contextualSearchContextData}";
     TemplateURL* template_url = new TemplateURL(data);
     // Takes ownership of |template_url|.
@@ skipping 68 matching lines @@
   bool is_invalid() { return is_invalid_; }
   int response_code() { return response_code_; }
   std::string search_term() { return search_term_; }
   std::string display_text() { return display_text_; }
   std::string alternate_term() { return alternate_term_; }
   bool do_prevent_preload() { return prevent_preload_; }
   std::string before_text() { return before_text_; }
   std::string after_text() { return after_text_; }
   int start_adjust() { return start_adjust_; }
   int end_adjust() { return end_adjust_; }
+  std::string language() { return language_; }
 
   // The delegate under test.
   scoped_ptr<ContextualSearchDelegate> delegate_;
 
  private:
-  void recordSearchTermResolutionResponse(bool is_invalid,
-                                          int response_code,
-                                          const std::string& search_term,
-                                          const std::string& display_text,
-                                          const std::string& alternate_term,
-                                          bool prevent_preload,
-                                          int start_adjust,
-                                          int end_adjust) {
-    is_invalid_ = is_invalid;
-    response_code_ = response_code;
-    search_term_ = search_term;
-    display_text_ = display_text;
-    alternate_term_ = alternate_term;
-    prevent_preload_ = prevent_preload;
-    start_adjust_ = start_adjust;
-    end_adjust_ = end_adjust;
+  void recordSearchTermResolutionResponse(
+      const ResolvedSearchTerm& resolved_search_term) {
+    is_invalid_ = resolved_search_term.is_invalid;
+    response_code_ = resolved_search_term.response_code;
+    search_term_ = resolved_search_term.search_term;
+    display_text_ = resolved_search_term.display_text;
+    alternate_term_ = resolved_search_term.alternate_term;
+    prevent_preload_ = resolved_search_term.prevent_preload;
+    start_adjust_ = resolved_search_term.selection_start_adjust;
+    end_adjust_ = resolved_search_term.selection_end_adjust;
+    language_ = resolved_search_term.language;
   }
 
   void recordSurroundingText(const std::string& before_text,
                              const std::string& after_text) {
     before_text_ = before_text;
     after_text_ = after_text;
   }
 
   void recordIcingSelectionAvailable(const std::string& encoding,
                                      const base::string16& surrounding_text,
                                      size_t start_offset,
                                      size_t end_offset) {
     // unused.
   }
 
   bool is_invalid_;
   int response_code_;
   std::string search_term_;
   std::string display_text_;
   std::string alternate_term_;
   bool prevent_preload_;
   int start_adjust_;
   int end_adjust_;
   std::string before_text_;
   std::string after_text_;
+  std::string language_;
 
   base::MessageLoopForIO io_message_loop_;
   net::TestURLFetcherFactory test_factory_;
   net::TestURLFetcher* fetcher_;
   scoped_ptr<TemplateURLService> template_url_service_;
   scoped_refptr<net::TestURLRequestContextGetter> request_context_;
 
   // Will be owned by the delegate.
   ContextualSearchContext* test_context_;
 
@@ skipping 248 matching lines @@
   int limit_each_side = -2;
   size_t start = 8;
   size_t end = 20;
   base::string16 result =
       delegate_->SurroundingTextForIcing(sample, limit_each_side, &start, &end);
   EXPECT_EQ(static_cast<size_t>(0), start);
   EXPECT_EQ(static_cast<size_t>(12), end);
   EXPECT_EQ(base::ASCIIToUTF16("Barack Obama"), result);
 }
 
-TEST_F(ContextualSearchDelegateTest, DecodeSearchTermsFromJsonResponse) {
+TEST_F(ContextualSearchDelegateTest, DecodeSearchTermFromJsonResponse) {
   std::string json_with_escape =
       ")]}'\n"
       "{\"mid\":\"/m/02mjmr\", \"search_term\":\"obama\","
       "\"info_text\":\"44th U.S. President\","
       "\"display_text\":\"Barack Obama\", \"mentions\":[0,15],"
       "\"selected_text\":\"obama\", \"resolved_term\":\"barack obama\"}";
   std::string search_term;
   std::string display_text;
   std::string alternate_term;
   std::string prevent_preload;
   int mention_start;
   int mention_end;
-  delegate_->DecodeSearchTermsFromJsonResponse(json_with_escape, &search_term,
-                                               &display_text, &alternate_term,
-                                               &prevent_preload, &mention_start,
-                                               &mention_end);
+  std::string language;
+  delegate_->DecodeSearchTermFromJsonResponse(
+      json_with_escape, &search_term, &display_text, &alternate_term,
+      &prevent_preload, &mention_start, &mention_end, &language);
   EXPECT_EQ("obama", search_term);
   EXPECT_EQ("Barack Obama", display_text);
   EXPECT_EQ("barack obama", alternate_term);
   EXPECT_EQ("", prevent_preload);
+  EXPECT_EQ("", language);
 }
+
+TEST_F(ContextualSearchDelegateTest, ResponseWithLanguage) {
+  CreateDefaultSearchContextAndRequestSearchTerm();
+  fetcher()->set_response_code(200);
+  fetcher()->SetResponseString(
+      "{\"mid\":\"/m/02mjmr\",\"search_term\":\"obama\","
+      "\"mentions\":[0,15],\"prevent_preload\":\"1\", "
+      "\"lang\":\"de\"}");
+  fetcher()->delegate()->OnURLFetchComplete(fetcher());
+
+  EXPECT_FALSE(is_invalid());
+  EXPECT_EQ(200, response_code());
+  EXPECT_EQ("obama", search_term());
+  EXPECT_EQ("obama", display_text());
+  EXPECT_TRUE(do_prevent_preload());
+  EXPECT_TRUE(DoesRequestContainOurSpecificBasePage());
+  EXPECT_EQ("de", language());
+}