android: add ThumbnailCache

chrome/browser/android/thumbnail/thumbnail_cache.h

+// 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.
+
+#ifndef CHROME_BROWSER_ANDROID_THUMBNAIL_THUMBNAIL_CACHE_H_
+#define CHROME_BROWSER_ANDROID_THUMBNAIL_THUMBNAIL_CACHE_H_
+
+#include <list>
+#include <set>
+#include <string>
+
+#include "base/bind.h"
+#include "base/containers/hash_tables.h"
+#include "base/files/file_path.h"
+#include "base/memory/ref_counted.h"
+#include "base/observer_list.h"
+#include "base/threading/thread.h"
+#include "base/time/time.h"
+#include "chrome/browser/android/thumbnail/lru_expiring_cache.h"
+#include "chrome/browser/android/thumbnail/thumbnail.h"
+#include "content/public/browser/android/ui_resource_client_android.h"
+#include "content/public/browser/android/ui_resource_provider.h"
+#include "third_party/skia/include/core/SkBitmap.h"
+#include "ui/gfx/geometry/point.h"
+#include "ui/gfx/geometry/size.h"
+#include "ui/gfx/geometry/size_f.h"
+#include "url/gurl.h"
+
+namespace base {
+class File;
+class Time;
+}
+
+namespace content {
+class ContentViewCore;
+}
+
+typedef std::list<TabId> TabIdList;
+
+class ThumbnailCacheObserver {
+ public:
+  virtual void OnFinishedThumbnailRead(TabId tab_id) = 0;
+};
+
+class ThumbnailCache : ThumbnailManager {
+ public:
+  ThumbnailCache(const std::string& disk_cache_path_str,
+                 size_t default_cache_size,
+                 size_t approximation_cache_size,
+                 size_t compression_queue_max_size,
+                 size_t write_queue_max_size,
+                 bool use_approximation_thumbnail);
+
+  ~ThumbnailCache();
+
+  void SetUIResourceProvider(content::UIResourceProvider* ui_resource_provider);
+
+  void AddThumbnailCacheObserver(ThumbnailCacheObserver* observer);
+  void RemoveThumbnailCacheObserver(
+      ThumbnailCacheObserver* observer);
+
+  void Put(TabId tab_id, const SkBitmap& bitmap, float thumbnail_scale);
+  void Remove(TabId tab_id);
+  const Thumbnail& Get(TabId tab_id);
+
+  void RemoveFromDiskAtAndAboveId(TabId min_id);
+  void InvalidateThumbnailIfChanged(TabId tab_id, const GURL& url);
+  bool CheckAndUpdateThumbnailMetaData(TabId tab_id, const GURL& url);
+  void UpdateVisibleIds(const TabIdList& priority);
+
+  // ThumbnailManager implementation
+  virtual void InvalidateCachedThumbnail(const Thumbnail& thumbnail) OVERRIDE;
+
+ private:
+  class ThumbnailMetaData {
+   public:
+    ThumbnailMetaData();
+    ThumbnailMetaData(const base::Time& current_time, const GURL& url);
+    const GURL& url() const { return url_; }
+    base::Time capture_time() const { return capture_time_; }
+
+   private:
+    base::Time capture_time_;
+    GURL url_;
+  };
+
+  class CompressedDataTransport
+      : public base::RefCountedThreadSafe<CompressedDataTransport> {
+   public:
+    CompressedDataTransport() : scale(0) {}
+
+    skia::RefPtr<SkPixelRef> compressed_data;
+    gfx::Size content_size;
+    float scale;
+
+   protected:
+    ~CompressedDataTransport() {}
+    friend class base::RefCountedThreadSafe<CompressedDataTransport>;
+  };
+
+  class WriteTaskResult
+      : public base::RefCountedThreadSafe<WriteTaskResult> {
+   public:
+    WriteTaskResult() : success_(false) {}
+    void SetSuccess(bool success) { success_ = success; }
+    bool success() { return success_; }
+
+   private:
+    bool success_;
+    friend class base::RefCountedThreadSafe<WriteTaskResult>;
+  };
+
+  typedef LRUExpiringCache<TabId, Thumbnail> ExpiringThumbnailCache;
+  typedef base::hash_map<TabId, ThumbnailMetaData> ThumbnailMetaDataMap;
+  typedef std::set<TabId> WrittenThumbnailSet;
+
+  void RemoveFromDisk(TabId tab_id);
+  static void RemoveFromDiskTask(const base::FilePath& file_path);
+  static void RemoveFromDiskAtAndAboveIdTask(const base::FilePath& dir_path,
+                                             TabId min_id);
+
+  void WriteThumbnailIfNecessary(TabId tab_id,
+                                 skia::RefPtr<SkPixelRef> compressed_data,
+                                 float scale,
+                                 const gfx::Size& content_size);
+
+  void CompressThumbnailIfNecessary(TabId tab_id,
+                                    const SkBitmap& bitmap,
+                                    float scale,
+                                    base::Time& time_stamp);
+  void ReadNextThumbnail();
+
+  void MakeSpaceForNewItemIfNecessary(TabId tab_id);
+
+  void RemoveFromReadQueue(TabId tab_id);
+
+  base::FilePath GetFilePath(TabId tab_id) const;
+
+  static void WriteTask(const base::FilePath& file_path,
+                        skia::RefPtr<SkPixelRef> compressed_data,
+                        float scale,
+                        const gfx::Size& content_size,
+                        scoped_refptr<WriteTaskResult> result);
+  void PostWriteTask(TabId tab_id, scoped_refptr<WriteTaskResult> result);
+
+  static void CompressionTask(SkBitmap bitmap,
+                              scoped_refptr<CompressedDataTransport> transport);
+  void PostCompressionTask(TabId tab_id,
+                           float scale,
+                           const base::Time& time_stamp,
+                           scoped_refptr<CompressedDataTransport> transport);
+
+  static void ReadTask(const base::FilePath& file_path,
+                       scoped_refptr<CompressedDataTransport> transport);
+  void PostReadTask(TabId tab_id,
+                    scoped_refptr<CompressedDataTransport> transport);
+
+  void NotifyObserversOfThumbnailRead(TabId tab_id);
+
+  static std::pair<SkBitmap, float> CreateApproximation(const SkBitmap& bitmap,
+                                                        float scale);
+
+  const base::FilePath disk_cache_path_;
+  const size_t compression_queue_max_size_;
+  const size_t write_queue_max_size_;
+  const bool use_approximation_thumbnail_;
+
+  size_t compression_tasks_count_;
+  size_t write_tasks_count_;
+
+  ExpiringThumbnailCache cache_;
+  ExpiringThumbnailCache approximation_cache_;
+  ObserverList<ThumbnailCacheObserver> observers_;
+  ThumbnailMetaDataMap thumbnail_meta_data_;
+  TabIdList read_queue_;
+  TabIdList visible_ids_;
+  WrittenThumbnailSet written_thumbnails_;
+
+  content::UIResourceProvider* ui_resource_provider_;
+  base::Thread compression_thread_;
+
+  base::WeakPtrFactory<ThumbnailCache> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(ThumbnailCache);
+};
+
+#endif  // CHROME_BROWSER_ANDROID_THUMBNAIL_THUMBNAIL_CACHE_H_