Revert of [Suggestions] Create ImageEncoder, to abstract away image encode/decode.

components/suggestions/image_manager.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/suggestions/image_manager.h"
 
 #include "base/bind.h"
-#include "components/suggestions/image_encoder.h"
 #include "components/suggestions/image_fetcher.h"
+#include "ui/gfx/codec/jpeg_codec.h"
 
 using leveldb_proto::ProtoDatabase;
 
+namespace {
+
+// From JPEG-encoded bytes to SkBitmap.
+SkBitmap* DecodeImage(const std::vector<unsigned char>& encoded_data) {
+  return gfx::JPEGCodec::Decode(&encoded_data[0], encoded_data.size());
+}
+
+}  // namespace
+
 namespace suggestions {
 
 ImageManager::ImageManager() : weak_ptr_factory_(this) {}
 
 ImageManager::ImageManager(scoped_ptr<ImageFetcher> image_fetcher,
-                           scoped_ptr<ImageEncoder> image_encoder,
                            scoped_ptr<ProtoDatabase<ImageData> > database,
                            const base::FilePath& database_dir)
     : image_fetcher_(image_fetcher.Pass()),
-      image_encoder_(image_encoder.Pass()),
       database_(database.Pass()),
       database_ready_(false),
       weak_ptr_factory_(this) {
   image_fetcher_->SetImageFetcherDelegate(this);
   database_->Init(database_dir, base::Bind(&ImageManager::OnDatabaseInit,
                                            weak_ptr_factory_.GetWeakPtr()));
 }
 
 ImageManager::~ImageManager() {}
 
@@ skipping 92 matching lines @@
 
 void ImageManager::SaveImage(const GURL& url, const SkBitmap& bitmap) {
   // Update the image map.
   image_map_.insert(std::make_pair(url.spec(), bitmap));
 
   if (!database_ready_) return;
 
   // Attempt to save a JPEG representation to the database. If not successful,
   // the fetched bitmap will still be inserted in the cache, above.
   std::vector<unsigned char> encoded_data;
-  if (image_encoder_->EncodeImage(bitmap, &encoded_data)) {
+  if (EncodeImage(bitmap, &encoded_data)) {
     // Save the resulting bitmap to the database.
     ImageData data;
     data.set_url(url.spec());
     data.set_data(std::string(encoded_data.begin(), encoded_data.end()));
     scoped_ptr<ProtoDatabase<ImageData>::KeyEntryVector> entries_to_save(
         new ProtoDatabase<ImageData>::KeyEntryVector());
     scoped_ptr<std::vector<std::string> > keys_to_remove(
         new std::vector<std::string>());
     entries_to_save->push_back(std::make_pair(data.url(), data));
     database_->UpdateEntries(entries_to_save.Pass(), keys_to_remove.Pass(),
@@ skipping 34 matching lines @@
     database_ready_ = false;
   }
 }
 
 void ImageManager::LoadEntriesInCache(scoped_ptr<ImageDataVector> entries) {
   for (ImageDataVector::iterator it = entries->begin(); it != entries->end();
        ++it) {
     std::vector<unsigned char> encoded_data(it->data().begin(),
                                             it->data().end());
 
-    scoped_ptr<SkBitmap> bitmap(image_encoder_->DecodeImage(encoded_data));
+    scoped_ptr<SkBitmap> bitmap(DecodeImage(encoded_data));
     if (bitmap.get()) {
       image_map_.insert(std::make_pair(it->url(), *bitmap));
     }
   }
 }
 
 void ImageManager::ServePendingCacheRequests() {
   for (ImageCacheRequestMap::iterator it = pending_cache_requests_.begin();
        it != pending_cache_requests_.end(); ++it) {
     const ImageCacheRequest& request = it->second;
     for (CallbackVector::const_iterator callback_it = request.callbacks.begin();
          callback_it != request.callbacks.end(); ++callback_it) {
       ServeFromCacheOrNetwork(request.url, request.image_url, *callback_it);
     }
   }
 }
 
+// static
+bool ImageManager::EncodeImage(const SkBitmap& bitmap,
+                               std::vector<unsigned char>* dest) {
+  SkAutoLockPixels bitmap_lock(bitmap);
+  if (!bitmap.readyToDraw() || bitmap.isNull()) {
+    return false;
+  }
+  return gfx::JPEGCodec::Encode(
+      reinterpret_cast<unsigned char*>(bitmap.getAddr32(0, 0)),
+      gfx::JPEGCodec::FORMAT_SkBitmap, bitmap.width(), bitmap.height(),
+      bitmap.rowBytes(), 100, dest);
+}
+
 }  // namespace suggestions