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

components/search_engines/template_url.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 "components/search_engines/template_url.h"
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 305 matching lines @@
   // boundary delimiter line. Uses random number generator here to create
   // a unique boundary delimiter for form data encoding.
   std::string boundary = base::StringPrintf(kMultipartBoundary,
                                             base::RandUint64());
   // Sets the content MIME type.
   post_content->first = kUploadDataMIMEType;
   post_content->first += boundary;
   // Encodes the post parameters.
   std::string* post_data = &post_content->second;
   post_data->clear();
-  for (PostParams::const_iterator param = post_params.begin();
-       param != post_params.end(); ++param) {
-    DCHECK(!param->first.empty());
-    net::AddMultipartValueForUpload(param->first, param->second, boundary,
-                                    std::string(), post_data);
+  for (const auto& param : post_params) {
+    DCHECK(!param.name.empty());
+    net::AddMultipartValueForUpload(param.name, param.value, boundary,
+                                    param.content_type, post_data);
   }
   net::AddMultipartFinalDelimiterForUpload(boundary, post_data);
   return true;
 }
 
 bool TemplateURLRef::SupportsReplacement(
     const SearchTermsData& search_terms_data) const {
   ParseIfNecessary(search_terms_data);
   return valid_ && supports_replacements_;
 }
@@ skipping 366 matching lines @@
       Strings parts;
       // The '=' delimiter is required and the name must be not empty.
       base::SplitString(*iterator, '=', &parts);
       if ((parts.size() != 2U) || parts[0].empty())
         return std::string();
 
       std::string& value = parts[1];
       size_t replacements_size = replacements->size();
       if (IsTemplateParameterString(value))
         ParseParameter(0, value.length() - 1, &value, replacements);
-      post_params->push_back(std::make_pair(parts[0], value));
+      PostParam param = { parts[0], value };
+      post_params->push_back(param);
       // If there was a replacement added, points its index to last added
       // PostParam.
       if (replacements->size() > replacements_size) {
         DCHECK_EQ(replacements_size + 1, replacements->size());
         Replacement* r = &replacements->back();
         r->is_post_param = true;
         r->index = post_params->size() - 1;
       }
     }
     DCHECK(!post_params->empty());
@@ skipping 62 matching lines @@
   path_ = url.path();
 }
 
 void TemplateURLRef::HandleReplacement(const std::string& name,
                                        const std::string& value,
                                        const Replacement& replacement,
                                        std::string* url) const {
   size_t pos = replacement.index;
   if (replacement.is_post_param) {
     DCHECK_LT(pos, post_params_.size());
-    DCHECK(!post_params_[pos].first.empty());
-    post_params_[pos].second = value;
+    DCHECK(!post_params_[pos].name.empty());
+    post_params_[pos].value = value;
   } else {
     url->insert(pos, name.empty() ? value : (name + "=" + value + "&"));
   }
 }
 
 std::string TemplateURLRef::HandleReplacements(
     const SearchTermsArgs& search_terms_args,
     const SearchTermsData& search_terms_data,
     PostContent* post_content) const {
   if (replacements_.empty()) {
@@ skipping 278 matching lines @@
         break;
 
       case SEARCH_TERMS:
         HandleReplacement(
             std::string(), base::UTF16ToUTF8(encoded_terms), *i, &url);
         break;
 
       case GOOGLE_IMAGE_THUMBNAIL:
         HandleReplacement(
             std::string(), search_terms_args.image_thumbnail_content, *i, &url);
+        post_params_[i->index].content_type = "image/jpeg";
         break;
 
       case GOOGLE_IMAGE_URL:
         if (search_terms_args.image_url.is_valid()) {
           HandleReplacement(
               std::string(), search_terms_args.image_url.spec(), *i, &url);
         }
         break;
 
       case GOOGLE_IMAGE_ORIGINAL_WIDTH:
@@ skipping 355 matching lines @@
       // patterns. This means that given patterns
       //    [ "http://foo/#q={searchTerms}", "http://foo/?q={searchTerms}" ],
       // calling ExtractSearchTermsFromURL() on "http://foo/?q=bar#q=' would
       // return false. This is important for at least Google, where such URLs
       // are invalid.
       return !search_terms->empty();
     }
   }
   return false;
 }