android-5.1.1_r30/s

// 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 "chrome/browser/search/suggestions/image_manager_impl.h"

#include "base/memory/ref_counted_memory.h"
#include "content/public/browser/browser_thread.h"
#include "net/base/load_flags.h"
#include "net/url_request/url_request_context_getter.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 {

ImageManagerImpl::ImageManagerImpl() : weak_ptr_factory_(this) {}

ImageManagerImpl::ImageManagerImpl(
    net::URLRequestContextGetter* url_request_context,
    scoped_ptr<ProtoDatabase<ImageData> > database,
    const base::FilePath& database_dir)
    : url_request_context_(url_request_context),
      database_(database.Pass()),
      database_ready_(false),
      weak_ptr_factory_(this) {
  database_->Init(database_dir, base::Bind(&ImageManagerImpl::OnDatabaseInit,
                                           weak_ptr_factory_.GetWeakPtr()));
}

ImageManagerImpl::~ImageManagerImpl() {}

ImageManagerImpl::ImageRequest::ImageRequest() : fetcher(NULL) {}

ImageManagerImpl::ImageRequest::ImageRequest(chrome::BitmapFetcher* f)
    : fetcher(f) {}

ImageManagerImpl::ImageRequest::~ImageRequest() { delete fetcher; }

void ImageManagerImpl::Initialize(const SuggestionsProfile& suggestions) {
  image_url_map_.clear();
  for (int i = 0; i < suggestions.suggestions_size(); ++i) {
    const ChromeSuggestion& suggestion = suggestions.suggestions(i);
    if (suggestion.has_thumbnail()) {
      image_url_map_[GURL(suggestion.url())] = GURL(suggestion.thumbnail());
    }
  }
}

void ImageManagerImpl::GetImageForURL(
    const GURL& url,
    base::Callback<void(const GURL&, const SkBitmap*)> callback) {
  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
  // If |url| is not found in |image_url_map_|, then invoke |callback| with
  // NULL since there is no associated image for this |url|.
  GURL image_url;
  if (!GetImageURL(url, &image_url)) {
    callback.Run(url, NULL);
    return;
  }

  // |database_| can be NULL if something went wrong in initialization.
  if (database_.get() && !database_ready_) {
    // Once database is initialized, it will serve pending requests from either
    // cache or network.
    QueueCacheRequest(url, image_url, callback);
    return;
  }

  ServeFromCacheOrNetwork(url, image_url, callback);
}

bool ImageManagerImpl::GetImageURL(const GURL& url, GURL* image_url) {
  std::map<GURL, GURL>::iterator it = image_url_map_.find(url);
  if (it == image_url_map_.end()) return false;  // Not found.
  *image_url = it->second;
  return true;
}

void ImageManagerImpl::QueueCacheRequest(
    const GURL& url, const GURL& image_url,
    base::Callback<void(const GURL&, const SkBitmap*)> callback) {
  // To be served when the database has loaded.
  ImageRequestMap::iterator it = pending_cache_requests_.find(url);
  if (it == pending_cache_requests_.end()) {
    ImageRequest request(NULL);
    request.url = url;
    request.image_url = image_url;
    request.callbacks.push_back(callback);
    pending_cache_requests_[url].swap(&request);
  } else {
    // Request already queued for this url.
    it->second.callbacks.push_back(callback);
  }
}

void ImageManagerImpl::ServeFromCacheOrNetwork(
    const GURL& url, const GURL& image_url,
    base::Callback<void(const GURL&, const SkBitmap*)> callback) {
  // If there is a image available in memory, return it.
  if (!ServeFromCache(url, callback)) {
    StartOrQueueNetworkRequest(url, image_url, callback);
  }
}

bool ImageManagerImpl::ServeFromCache(
    const GURL& url,
    base::Callback<void(const GURL&, const SkBitmap*)> callback) {
  SkBitmap* bitmap = GetBitmapFromCache(url);
  if (bitmap) {
    callback.Run(url, bitmap);
    return true;
  }
  return false;
}

SkBitmap* ImageManagerImpl::GetBitmapFromCache(const GURL& url) {
  ImageMap::iterator image_iter = image_map_.find(url.spec());
  if (image_iter != image_map_.end()) {
    return &image_iter->second;
  }
  return NULL;
}

void ImageManagerImpl::StartOrQueueNetworkRequest(
    const GURL& url, const GURL& image_url,
    base::Callback<void(const GURL&, const SkBitmap*)> callback) {
  // Before starting to fetch the image. Look for a request in progress for
  // |image_url|, and queue if appropriate.
  ImageRequestMap::iterator it = pending_net_requests_.find(image_url);
  if (it == pending_net_requests_.end()) {
    // |image_url| is not being fetched, so create a request and initiate
    // the fetch.
    ImageRequest request(new chrome::BitmapFetcher(image_url, this));
    request.url = url;
    request.callbacks.push_back(callback);
    request.fetcher->Start(
        url_request_context_, std::string(),
        net::URLRequest::CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE,
        net::LOAD_NORMAL);
    pending_net_requests_[image_url].swap(&request);
  } else {
    // Request in progress. Register as an interested callback.
    it->second.callbacks.push_back(callback);
  }
}

void ImageManagerImpl::OnFetchComplete(const GURL image_url,
                                       const SkBitmap* bitmap) {
  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));

  ImageRequestMap::iterator image_iter = pending_net_requests_.find(image_url);
  DCHECK(image_iter != pending_net_requests_.end());

  ImageRequest* request = &image_iter->second;

  // Here |bitmap| could be NULL or a pointer to a bitmap which is owned by the
  // BitmapFetcher and which ceases to exist after this function. Pass the
  // un-owned pointer to the registered callbacks.
  for (CallbackVector::iterator callback_iter = request->callbacks.begin();
       callback_iter != request->callbacks.end(); ++callback_iter) {
    callback_iter->Run(request->url, bitmap);
  }

  // Save the bitmap to the in-memory model as well as the database, because it
  // is now the freshest representation of the image.
  // TODO(mathp): Handle null (no image found), possible deletion in DB.
  if (bitmap) SaveImage(request->url, *bitmap);

  // Erase the completed ImageRequest.
  pending_net_requests_.erase(image_iter);
}

void ImageManagerImpl::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 (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(),
                             base::Bind(&ImageManagerImpl::OnDatabaseSave,
                                        weak_ptr_factory_.GetWeakPtr()));
  }
}

void ImageManagerImpl::OnDatabaseInit(bool success) {
  if (!success) {
    DVLOG(1) << "Image database init failed.";
    database_.reset();
    ServePendingCacheRequests();
    return;
  }
  database_->LoadEntries(base::Bind(&ImageManagerImpl::OnDatabaseLoad,
                                    weak_ptr_factory_.GetWeakPtr()));
}

void ImageManagerImpl::OnDatabaseLoad(bool success,
                                      scoped_ptr<ImageDataVector> entries) {
  if (!success) {
    DVLOG(1) << "Image database load failed.";
    database_.reset();
    ServePendingCacheRequests();
    return;
  }
  database_ready_ = true;

  LoadEntriesInCache(entries.Pass());
  ServePendingCacheRequests();
}

void ImageManagerImpl::OnDatabaseSave(bool success) {
  if (!success) {
    DVLOG(1) << "Image database save failed.";
    database_.reset();
    database_ready_ = false;
  }
}

void ImageManagerImpl::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(DecodeImage(encoded_data));
    if (bitmap.get()) {
      image_map_.insert(std::make_pair(it->url(), *bitmap));
    }
  }
}

void ImageManagerImpl::ServePendingCacheRequests() {
  for (ImageRequestMap::iterator it = pending_cache_requests_.begin();
       it != pending_cache_requests_.end(); ++it) {
    const ImageRequest& 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 ImageManagerImpl::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.width() * bitmap.bytesPerPixel(), 100, dest);
}

}  // namespace suggestions