Enabled the "search web for image" context menu item when "Yandex"

components/search_engines/template_url_unittest.cc

 // Copyright 2014 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 "base/base_paths.h"
 #include "base/command_line.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/metrics/proto/omnibox_event.pb.h"
@@ skipping 140 matching lines @@
   TemplateURLData data;
   data.image_url = KImageSearchURL;
 
   // Try to parse invalid post parameters.
   data.image_url_post_params = kInvalidPostParamsString;
   TemplateURL url_bad(data);
   ASSERT_FALSE(url_bad.image_url_ref().IsValid(search_terms_data_));
   const TemplateURLRef::PostParams& bad_post_params =
       url_bad.image_url_ref().post_params_;
   ASSERT_EQ(2U, bad_post_params.size());
-  EXPECT_EQ("unknown_template", bad_post_params[0].first);
-  EXPECT_EQ("{UnknownTemplate}", bad_post_params[0].second);
-  EXPECT_EQ("bad_value", bad_post_params[1].first);
-  EXPECT_EQ("bad{value}", bad_post_params[1].second);
+  EXPECT_EQ("unknown_template", bad_post_params[0].value_name);

[Peter Kasting, 2015/02/18 21:55:52]

Nit: Many of these place you're touching might get shorter (and perhaps more
readable) if you added some helper function like

  ExpectPostParamIs(const PostParam& param,
                    const std::string& name,
                    const std::string& value,
                    const std::string& content_type);

...and did the EXPECT_EQs in there.

[Vitaly Baranov, 2015/02/19 17:31:20]

Done.

+  EXPECT_EQ("{UnknownTemplate}", bad_post_params[0].value);
+  EXPECT_TRUE(bad_post_params[0].content_type.empty());
+  EXPECT_EQ("bad_value", bad_post_params[1].value_name);
+  EXPECT_EQ("bad{value}", bad_post_params[1].value);
+  EXPECT_TRUE(bad_post_params[1].content_type.empty());
 
   // Try to parse valid post parameters.
   data.image_url_post_params = kValidPostParamsString;
   TemplateURL url(data);
   ASSERT_TRUE(url.image_url_ref().IsValid(search_terms_data_));
   ASSERT_FALSE(url.image_url_ref().SupportsReplacement(search_terms_data_));
 
   // Check term replacement.
   TemplateURLRef::SearchTermsArgs search_args(ASCIIToUTF16("X"));
   search_args.image_thumbnail_content = "dummy-image-thumbnail";
+  search_args.image_thumbnail_format = "jpeg";
   search_args.image_url = GURL("http://dummyimage.com/dummy.jpg");
   search_args.image_original_size = gfx::Size(10, 10);
   // Replacement operation with no post_data buffer should still return
   // the parsed URL.
   TestingSearchTermsData search_terms_data("http://X");
   GURL result(url.image_url_ref().ReplaceSearchTerms(
       search_args, search_terms_data));
   ASSERT_TRUE(result.is_valid());
   EXPECT_EQ(KImageSearchURL, result.spec());
   TemplateURLRef::PostContent post_content;
@@ skipping 11 matching lines @@
       url.image_url_ref().post_params_;
   EXPECT_EQ(7U, post_params.size());
   for (TemplateURLRef::PostParams::const_iterator i = post_params.begin();
        i != post_params.end(); ++i) {
     TemplateURLRef::Replacements::const_iterator j = replacements.begin();
     for (; j != replacements.end(); ++j) {
       if (j->is_post_param && j->index ==
           static_cast<size_t>(i - post_params.begin())) {
         switch (j->type) {
           case TemplateURLRef::GOOGLE_IMAGE_ORIGINAL_WIDTH:
-            EXPECT_EQ("width", i->first);
+            EXPECT_EQ("width", i->value_name);
             EXPECT_EQ(
                 base::IntToString(search_args.image_original_size.width()),
-                i->second);
+                i->value);
+            EXPECT_TRUE(i->content_type.empty());
             break;
           case TemplateURLRef::GOOGLE_IMAGE_SEARCH_SOURCE:
-            EXPECT_EQ("sbisrc", i->first);
-            EXPECT_EQ(search_terms_data.GoogleImageSearchSource(), i->second);
+            EXPECT_EQ("sbisrc", i->value_name);
+            EXPECT_EQ(search_terms_data.GoogleImageSearchSource(), i->value);
+            EXPECT_TRUE(i->content_type.empty());
             break;
           case TemplateURLRef::GOOGLE_IMAGE_THUMBNAIL:
-            EXPECT_EQ("image_content", i->first);
-            EXPECT_EQ(search_args.image_thumbnail_content, i->second);
+            EXPECT_EQ("image_content", i->value_name);
+            EXPECT_EQ(search_args.image_thumbnail_content, i->value);
+            EXPECT_EQ("image/" + search_args.image_thumbnail_format,
+                      i->content_type);
             break;
           case TemplateURLRef::GOOGLE_IMAGE_URL:
-            EXPECT_EQ("image_url", i->first);
-            EXPECT_EQ(search_args.image_url.spec(), i->second);
+            EXPECT_EQ("image_url", i->value_name);
+            EXPECT_EQ(search_args.image_url.spec(), i->value);
+            EXPECT_TRUE(i->content_type.empty());
             break;
           case TemplateURLRef::LANGUAGE:
-            EXPECT_EQ("language", i->first);
-            EXPECT_EQ("en", i->second);
+            EXPECT_EQ("language", i->value_name);
+            EXPECT_EQ("en", i->value);
+            EXPECT_TRUE(i->content_type.empty());
             break;
           default:
             ADD_FAILURE();  // Should never go here.
         }
         break;
       }
     }
     if (j != replacements.end())
       continue;
-    if (i->first == "empty_param") {
-      EXPECT_TRUE(i->second.empty());
-    } else if (i->first == "sbisrc") {
-      EXPECT_FALSE(i->second.empty());
+    if (i->value_name == "empty_param") {
+      EXPECT_TRUE(i->value.empty());
+      EXPECT_TRUE(i->content_type.empty());
+    } else if (i->value_name == "sbisrc") {
+      EXPECT_FALSE(i->value.empty());
+      EXPECT_TRUE(i->content_type.empty());
     } else {
-      EXPECT_EQ("constant_param", i->first);
-      EXPECT_EQ("constant", i->second);
+      EXPECT_EQ("constant_param", i->value_name);
+      EXPECT_EQ("constant", i->value);
+      EXPECT_TRUE(i->content_type.empty());
     }
   }
 }
 
 // Test that setting the prepopulate ID from TemplateURL causes the stored
 // TemplateURLRef to handle parsing the URL parameters differently.
 TEST_F(TemplateURLTest, SetPrepopulatedAndParse) {
   TemplateURLData data;
   data.SetURL("http://foo{fhqwhgads}bar");
   TemplateURL url(data);
@@ skipping 1243 matching lines @@
   EXPECT_EQ("http://bar/search?q=foo&pfq=full%20query%20text&qha=2338&xssi=t",
             result);
 
   TemplateURL url2(data);
   search_terms_args.prefetch_query.clear();
   search_terms_args.prefetch_query_type.clear();
   result =
       url2.url_ref().ReplaceSearchTerms(search_terms_args, search_terms_data_);
   EXPECT_EQ("http://bar/search?q=foo&xssi=t", result);
 }