[Download Home] Add image thumbnail support

chrome/browser/android/download/ui/thumbnail_provider.cc

+// Copyright 2016 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/download/ui/thumbnail_provider.h"
+
+#include "base/android/jni_string.h"
+#include "base/files/file_path.h"
+#include "base/files/file_util.h"
+#include "base/memory/weak_ptr.h"
+#include "chrome/browser/image_decoder.h"
+#include "content/public/browser/browser_thread.h"
+#include "jni/ThumbnailProviderImpl_jni.h"
+#include "skia/ext/image_operations.h"
+#include "third_party/skia/include/core/SkBitmap.h"
+#include "ui/gfx/android/java_bitmap.h"
+#include "ui/gfx/skbitmap_operations.h"
+
+class SkBitmap;
+
+using base::android::JavaParamRef;
+
+namespace {
+
+// Ignore image files that are too large to avoid long delays.
+const int64_t kMaxImageSize = 10 * 1024 * 1024;  // 10 MB
+
+class ImageThumbnailRequest : public ImageDecoder::ImageRequest {
+ public:
+  ImageThumbnailRequest(int icon_size,
+                        const std::string& file_path,
+                        base::WeakPtr<ThumbnailProvider> weak_provider)
+    : icon_size_(icon_size),
+      file_path_(file_path),
+      weak_provider_(weak_provider) {
+  }
+
+  void Start() {
+    if (!content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE)) {

[Ted C, 2016/08/31 00:34:35]

let's pull this out to a separate function and make each method be only valid on
a particular thread.

[gone, 2016/08/31 01:35:04]

Turns out you can force all of this to be on the FILE thread.

+      content::BrowserThread::PostTask(
+          content::BrowserThread::FILE,
+          FROM_HERE,
+          base::Bind(&ImageThumbnailRequest::Start, base::Unretained(this)));
+      return;
+    }
+
+    // Re-check the file's size because it may have changed.

[Ted C, 2016/08/31 00:34:34]

I think "// Ensure the file does not exceed our max size threshold"

[gone, 2016/08/31 01:35:04]

Did some variant of this sentence.

+    int64_t file_size;
+    base::FilePath path = base::FilePath::FromUTF8Unsafe(file_path_);
+    if (!base::GetFileSize(path, &file_size) ||
+        file_size > kMaxImageSize) {
+      LOG(ERROR) << "Unexpected file size: " << file_path_ << ", " << file_size;
+      FinishRequest(SkBitmap());
+    }
+
+    // Make sure the file isn't empty.
+    std::string data;
+    bool success = base::ReadFileToString(path, &data);
+    if (!success || data.empty()) {
+      LOG(ERROR) << "Failed to read file: " << file_path_;
+      FinishRequest(SkBitmap());
+    }
+
+    ImageDecoder::Start(this, data);
+  }
+
+  void OnImageDecoded(const SkBitmap& decoded_image) override {
+    SkBitmap thumbnail = decoded_image;
+    if (!decoded_image.drawsNothing()) {
+      // Shrink the image down so that its smallest dimension is within range.
+      int min_dimension = std::min(decoded_image.width(),
+                                   decoded_image.height());
+
+      if (min_dimension > icon_size_) {
+        uint64_t width = static_cast<uint64_t>(decoded_image.width());
+        uint64_t height = static_cast<uint64_t>(decoded_image.height());
+        thumbnail = skia::ImageOperations::Resize(

[Ted C, 2016/08/31 00:34:35]

it'd be nice to not do this on the UI thread...don't know if that is possible.

[gone, 2016/08/31 01:35:04]

Done.

+                        decoded_image,

[Ted C, 2016/08/31 00:34:34]

this looks wonky to me.  I think it should be 4 from the start of the line, but
this is probably what git cl format does in c++ and git cl format wins there (vs
it's general failing in java land)

[gone, 2016/08/31 01:35:04]

Actually ran git cl format this time.

+                        skia::ImageOperations::RESIZE_BEST,
+                        width * icon_size_ / min_dimension,
+                        height * icon_size_ / min_dimension);
+      }
+    }
+
+    FinishRequest(thumbnail);
+  }
+
+  void OnDecodeImageFailed() override {
+    LOG(ERROR) << "Failed to decode image: " << file_path_;
+    FinishRequest(SkBitmap());
+  }
+
+ private:
+  void FinishRequest(const SkBitmap& thumbnail) {
+    if (!content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)) {
+      content::BrowserThread::PostTask(

[Ted C, 2016/08/31 00:34:35]

ideally the same comment as above and have anyone that is on a different thread
(looking at you Start() above) post this manually

This makes it a bit too easy to be sloppy with threading imo.

[gone, 2016/08/31 01:35:04]

Done.

+          content::BrowserThread::UI,
+          FROM_HERE,
+          base::Bind(&ImageThumbnailRequest::FinishRequest,
+                     base::Unretained(this), thumbnail));
+      return;
+    }
+
+    if (weak_provider_)
+      weak_provider_->OnThumbnailRetrieved(file_path_, thumbnail);
+    task_runner()->DeleteSoon(FROM_HERE, this);
+  }
+
+  const int icon_size_;
+  std::string file_path_;
+  base::WeakPtr<ThumbnailProvider> weak_provider_;
+
+  DISALLOW_IMPLICIT_CONSTRUCTORS(ImageThumbnailRequest);
+};
+
+}  // namespace
+
+ThumbnailProvider::ThumbnailProvider(const JavaParamRef<jobject>& jobj,
+                                     int icon_size)
+    : java_delegate_(jobj),
+      weak_factory_(this) {
+}
+
+ThumbnailProvider::~ThumbnailProvider() {
+  java_delegate_.Reset();
+  weak_factory_.InvalidateWeakPtrs();

[Ted C, 2016/08/31 00:34:35]

This happens as a result of destructing the WeakPtrFactory, which owns a
WeakReferenceOwner, ~WeakReferenceOwner calls Invalidate.

[gone, 2016/08/31 01:35:04]

Done.

+}
+
+void ThumbnailProvider::Destroy(JNIEnv* env,
+                                const JavaParamRef<jobject>& jobj) {
+  delete this;
+}
+
+void ThumbnailProvider::OnThumbnailRetrieved(const std::string& file_path,
+                                             const SkBitmap& thumbnail) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+
+  if (java_delegate_.is_null())
+    return;
+
+  // Send the bitmap back to Java-land.
+  JNIEnv* env = base::android::AttachCurrentThread();
+  Java_ThumbnailProviderImpl_onThumbnailRetrieved(
+      env,
+      java_delegate_,
+      base::android::ConvertUTF8ToJavaString(env, file_path),
+      gfx::ConvertToJavaBitmap(&thumbnail));
+}
+
+void ThumbnailProvider::RetrieveThumbnail(JNIEnv* env,
+                                          const JavaParamRef<jobject>& jobj,
+                                          jstring file_path,
+                                          jint icon_size) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+
+  // The ImageThumbnailRequest deletes itself on completion.
+  std::string path = base::android::ConvertJavaStringToUTF8(env, file_path);
+  ImageThumbnailRequest* request = new ImageThumbnailRequest(
+      icon_size, path, weak_factory_.GetWeakPtr());
+  request->Start();
+}
+
+// static
+bool ThumbnailProvider::RegisterJNI(JNIEnv* env) {
+  return RegisterNativesImpl(env);
+}
+
+// static
+static jlong Init(JNIEnv* env,
+                  const JavaParamRef<jobject>& jobj,
+                  int icon_size) {
+  return reinterpret_cast<intptr_t>(new ThumbnailProvider(jobj, icon_size));
+}