Merge lp:~nick-dedekind/unity/lp1062107.preview-pre-caching into lp:unity

[Nick Dedekind]

Added dash preview pre-caching. (LP: #1062107)

= Problem description =

https://bugs.launchpad.net/unity/+bug/1062107
Preview content should be speculatively cached

= The fix =

1. When the user opens a preview, results subsequent to the preview start pre-cacheing.

2. Once a user has previewed one content item underneath a category header, as long as the Dash remains open we continue to speculatively cache the preview content for the other items under the category header (even when the user returns to the results view). The pre-caching stops when a) the user closes the Dash b) the user previews the a result from underneath another category header. In this second case the Dash then starts speculatively pre-cacheing the content from underneath this new category header.

= Test coverage =

Unit tests for pre-caching queue execution.

[Brandon Schaefer (brandontschaefer)]

530 + virtual ~PreviewPreCacher();
551 + virtual void OnPreCacheComplete();

Could we make those pure virtual fucntions?

Or if not could we just do:
530 + virtual ~PreviewPreCacher() {}
551 + virtual void OnPreCacheComplete() {}

347 + if (index < 0 || index >=(int)GetResultCount())

Does this need to be casted to an int?

758 + int top_social_info_max_width = MAX(details_width - style.GetAppIconAreaWidth() - style.GetSpaceBetweenIconAndDetails(), 0);
772 + int max_width = MAX(0, geo_cr.width - 2*(geo_cr.width*0.1));
773 + int max_height = MAX(0, (geo_cr.height - TAIL_HEIGHT) - 2*((geo_cr.height - TAIL_HEIGHT)*0.1));
786 + title_->SetMaximumWidth(MAX(0, GetGeometry().width - geo.height - style.GetMusicDurationWidth() - layout_spacing*2));

Lets use std::max() here.

review: Needs Fixing

[Brandon Schaefer (brandontschaefer)]

bschaefer@bschaefer:unity$ bzr merge lp:~nick-dedekind/unity/lp1062107.preview-pre-caching
+N UnityCore/PreviewPreCacher.cpp
+N UnityCore/PreviewPreCacher.h
+N tests/test_previews_precacher.cpp
 M UnityCore/CMakeLists.txt
 M UnityCore/HomeLens.cpp
 M UnityCore/HomeLens.h
 M UnityCore/Lens.cpp
 M UnityCore/Lens.h
 M dash/DashView.cpp
 M dash/LensView.cpp
 M dash/LensView.h
 M dash/previews/PreviewContainer.cpp
 M dash/previews/SocialPreview.cpp
 M dash/previews/SocialPreviewContent.cpp
 M dash/previews/Track.cpp
 M tests/CMakeLists.txt
 M tests/test_lens.cpp
Text conflict in dash/LensView.cpp
Text conflict in dash/previews/Track.cpp
Text conflict in tests/CMakeLists.txt
3 conflicts encountered.

review: Needs Fixing

[Nick Dedekind (nick-dedekind)]

> 530 + virtual ~PreviewPreCacher();
> 551 + virtual void OnPreCacheComplete();
>
> Could we make those pure virtual fucntions?
>
> Or if not could we just do:
> 530 + virtual ~PreviewPreCacher() {}
> 551 + virtual void OnPreCacheComplete() {}
>

Can't be pure virtual because we need to instantiate a PreviewPreCacher.
Don't see any benefit in making them inline.

>
> 347 + if (index < 0 || index >=(int)GetResultCount())
>
> Does this need to be casted to an int?
>

Yes. GetResultCount returns an unsigned int. Comes from the dee model.

>
> 758 + int top_social_info_max_width = MAX(details_width -
> style.GetAppIconAreaWidth() - style.GetSpaceBetweenIconAndDetails(), 0);
> 772 + int max_width = MAX(0, geo_cr.width - 2*(geo_cr.width*0.1));
> 773 + int max_height = MAX(0, (geo_cr.height - TAIL_HEIGHT) -
> 2*((geo_cr.height - TAIL_HEIGHT)*0.1));
> 786 + title_->SetMaximumWidth(MAX(0, GetGeometry().width - geo.height -
> style.GetMusicDurationWidth() - layout_spacing*2));
>
> Lets use std::max() here.

Will do.

[lp:~nick-dedekind/unity/lp1062107.preview-pre-caching]

2880. By Nick Dedekind on 2012-12-10

switched preview code to use std::max

2881. By Nick Dedekind on 2012-12-10

Merged with trunk

[Nick Dedekind (nick-dedekind)]

Use std::max for preview code.
Merged with trunk.

[Andrea Azzarone (azzar1)]

tests/test_previews_precacher.cpp

I don't like the way you're testing PreviewPreCacher because you're testing a mock of it (MockPreviewPreCacher).

Also PreviewPreCacher should inherit from sigc::trackable.

[Nick Dedekind (nick-dedekind)]

@andyrock: As stated in the description, the supplied test is only meant to check the preview pre-caching sequence (pretty much only the PreviewPreCacher::ContinuePreCaching function).

Getting a lens view into the test harness to test the pre-cacher interaction is somewhat controversial and not suited to unit testing at the moment (Lens Dee related code is "too tight" for testability).
I am hoping to get some refactoring into the lenses soon so they can be properly tested. Once this is done, we can revisit this.

[Nick Dedekind (nick-dedekind)]

Some previews (eg MusicPreview) are stateful inside libunity, therefore asking for subsiquent previews while viewing another will hose the state.
Until this is recitfied, this cannot be merged.

Unmerged revisions

2881. By Nick Dedekind on 2012-12-10

Merged with trunk

2880. By Nick Dedekind on 2012-12-10

switched preview code to use std::max

2879. By Nick Dedekind on 2012-11-08

Preview pre-caching tweaks.

2878. By Nick Dedekind on 2012-11-07

Removed debuggin code.

2877. By Nick Dedekind on 2012-11-07

Added precache files.

2876. By Nick Dedekind on 2012-11-07

Added speculative caching to previews.

2875. By Nick Dedekind on 2012-11-07

Check for width > 0 in preview layout management.

=== modified file 'UnityCore/CMakeLists.txt'
--- UnityCore/CMakeLists.txt	2012-11-26 16:09:53 +0000
+++ UnityCore/CMakeLists.txt	2012-12-10 10:03:24 +0000
@@ -49,6 +49,7 @@
      ModelRowAdaptor.h
      ModelRowAdaptor-inl.h
      Preview.h
+     PreviewPreCacher.h
      RadioOptionFilter.h
      RatingsFilter.h
      Result.h
@@ -88,6 +89,7 @@
      MusicPreview.cpp
      ModelRowAdaptor.cpp
      Preview.cpp
+     PreviewPreCacher.cpp
      RatingsFilter.cpp
      RadioOptionFilter.cpp
      Result.cpp

=== modified file 'UnityCore/HomeLens.cpp'
--- UnityCore/HomeLens.cpp	2012-11-14 08:57:56 +0000
+++ UnityCore/HomeLens.cpp	2012-12-10 10:03:24 +0000
@@ -1218,14 +1218,14 @@
   }
 }
 
-void HomeLens::Preview(std::string const& uri)
+void HomeLens::Preview(std::string const& uri, GCancellable* cancellable, PreviewCallback const& slot)
 {
   LOG_DEBUG(logger) << "Preview '" << uri << "'";
 
   Lens::Ptr lens = pimpl->FindLensForUri(uri);
 
   if (lens)
-    lens->Preview(uri);
+    lens->Preview(uri, cancellable, slot);
   else
     LOG_WARN(logger) << "Unable to find a lens for previewing '" << uri << "'";
 }

=== modified file 'UnityCore/HomeLens.h'
--- UnityCore/HomeLens.h	2012-11-12 11:07:23 +0000
+++ UnityCore/HomeLens.h	2012-12-10 10:03:24 +0000
@@ -72,7 +72,7 @@
   void GlobalSearch(std::string const& search_string, SearchFinishedCallback const& cb);
   void Search(std::string const& search_string, SearchFinishedCallback const& cb);
   void Activate(std::string const& uri);
-  void Preview(std::string const& uri);
+  void Preview(std::string const& uri, GCancellable* cancellable, PreviewCallback const& slot);
 
   std::vector<unsigned> GetCategoriesOrder();
   glib::Object<DeeModel> GetFilterModelForCategory(unsigned category);

=== modified file 'UnityCore/Lens.cpp'
--- UnityCore/Lens.cpp	2012-11-14 08:57:56 +0000
+++ UnityCore/Lens.cpp	2012-12-10 10:03:24 +0000
@@ -84,8 +84,8 @@
   void GlobalSearch(std::string const& search_string, SearchFinishedCallback const& cb);
   void Search(std::string const& search_string, SearchFinishedCallback const& cb);
   void Activate(std::string const& uri);
-  void ActivationReply(GVariant* parameters);
-  void Preview(std::string const& uri);
+  void ActivationReply(GVariant* parameters, PreviewCallback const& slot);
+  void Preview(std::string const& uri, GCancellable* cancellable, PreviewCallback const& slot);
   void ActivatePreviewAction(std::string const& action_id,
                              std::string const& uri,
                              Hints const& hints);
@@ -143,7 +143,6 @@
   glib::DBusProxy* proxy_;
   glib::Object<GCancellable> search_cancellable_;
   glib::Object<GCancellable> global_search_cancellable_;
-  glib::Object<GCancellable> preview_cancellable_;
 
   glib::Variant results_variant_;
   glib::Variant global_results_variant_;
@@ -513,18 +512,18 @@
   LOG_DEBUG(logger) << "Activating '" << uri << "' on  '" << id_ << "'";
 
   if (!proxy_->IsConnected())
-    {
-      LOG_DEBUG(logger) << "Skipping activation. Proxy not connected. ('" << id_ << "')";
-      return;
-    }
+  {
+    LOG_DEBUG(logger) << "Skipping activation. Proxy not connected. ('" << id_ << "')";
+    return;
+  }
 
   proxy_->Call("Activate",
                g_variant_new("(su)", uri.c_str(),
                              UNITY_PROTOCOL_ACTION_TYPE_ACTIVATE_RESULT),
-               sigc::mem_fun(this, &Lens::Impl::ActivationReply));
+               sigc::bind(sigc::mem_fun(this, &Lens::Impl::ActivationReply), std::nullptr_t()));
 }
 
-void Lens::Impl::ActivationReply(GVariant* parameters)
+void Lens::Impl::ActivationReply(GVariant* parameters, PreviewCallback const& slot)
 {
   glib::String uri;
   guint32 handled;
@@ -548,7 +547,14 @@
         // but that's not really doable from here
         preview->parent_lens = owner_;
         preview->preview_uri = uri.Str();
-        owner_->preview_ready.emit(uri.Str(), preview);
+        if (slot)
+        {
+          slot(uri.Str(), preview);
+        }
+        else
+        {
+          owner_->preview_ready.emit(uri.Str(), preview);
+        }
         return;
       }
     }
@@ -561,27 +567,21 @@
   }
 }
 
-void Lens::Impl::Preview(std::string const& uri)
+void Lens::Impl::Preview(std::string const& uri, GCancellable* cancellable, PreviewCallback const& slot)
 {
   LOG_DEBUG(logger) << "Previewing '" << uri << "' on  '" << id_ << "'";
 
   if (!proxy_->IsConnected())
-    {
-      LOG_DEBUG(logger) << "Skipping preview. Proxy not connected. ('" << id_ << "')";
-      return;
-    }
-
-  if (preview_cancellable_)
   {
-    g_cancellable_cancel(preview_cancellable_);
+    LOG_DEBUG(logger) << "Skipping preview. Proxy not connected. ('" << id_ << "')";
+    return;
   }
-  preview_cancellable_ = g_cancellable_new ();
 
   proxy_->Call("Activate",
                g_variant_new("(su)", uri.c_str(),
                              UNITY_PROTOCOL_ACTION_TYPE_PREVIEW_RESULT),
-               sigc::mem_fun(this, &Lens::Impl::ActivationReply),
-               preview_cancellable_);
+               sigc::bind(sigc::mem_fun(this, &Lens::Impl::ActivationReply), slot),
+               cancellable);
 }
 
 void Lens::Impl::ActivatePreviewAction(std::string const& action_id,
@@ -608,7 +608,7 @@
     proxy_->Call("Activate",
                  g_variant_new("(su)", activation_uri.c_str(),
                                UNITY_PROTOCOL_ACTION_TYPE_PREVIEW_ACTION),
-                 sigc::mem_fun(this, &Lens::Impl::ActivationReply));
+                 sigc::bind(sigc::mem_fun(this, &Lens::Impl::ActivationReply), std::nullptr_t()));
   }
   else
   {
@@ -625,7 +625,7 @@
                  g_variant_new("(sua{sv})", activation_uri.c_str(),
                                UNITY_PROTOCOL_ACTION_TYPE_PREVIEW_ACTION,
                                &b),
-                 sigc::mem_fun(this, &Lens::Impl::ActivationReply));
+                 sigc::bind(sigc::mem_fun(this, &Lens::Impl::ActivationReply), std::nullptr_t()));
 
     g_variant_builder_clear(&b);
   }
@@ -876,9 +876,9 @@
   pimpl->Activate(uri);
 }
 
-void Lens::Preview(std::string const& uri)
+void Lens::Preview(std::string const& uri, GCancellable* cancellable, PreviewCallback const& slot)
 {
-  pimpl->Preview(uri);
+  pimpl->Preview(uri, cancellable, slot);
 }
 
 void Lens::ActivatePreviewAction(std::string const& action_id,

=== modified file 'UnityCore/Lens.h'
--- UnityCore/Lens.h	2012-11-14 08:57:56 +0000
+++ UnityCore/Lens.h	2012-12-10 10:03:24 +0000
@@ -52,6 +52,8 @@
   LENS_VIEW
 };
 
+typedef std::function<void(std::string const&, Preview::Ptr const&)> PreviewCallback;
+
 class Lens : public sigc::trackable, boost::noncopyable
 {
 public:
@@ -85,7 +87,7 @@
   virtual void GlobalSearch(std::string const& search_string, SearchFinishedCallback const& cb = nullptr);
   virtual void Search(std::string const& search_string, SearchFinishedCallback const& cb = nullptr);
   virtual void Activate(std::string const& uri);
-  virtual void Preview(std::string const& uri);
+  virtual void Preview(std::string const& uri, GCancellable* cancellable, PreviewCallback const& slot);
   virtual void ActivatePreviewAction(std::string const& action_id,
                                      std::string const& uri,
                                      Hints const& hints);

=== added file 'UnityCore/PreviewPreCacher.cpp'
--- UnityCore/PreviewPreCacher.cpp	1970-01-01 00:00:00 +0000
+++ UnityCore/PreviewPreCacher.cpp	2012-12-10 10:03:24 +0000
@@ -0,0 +1,270 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2012 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Nick Dedekind <[e-mail]>
+ */
+
+#include "PreviewPreCacher.h"
+#include "Category.h"
+
+namespace unity
+{
+namespace dash
+{
+namespace previews
+{
+DECLARE_LOGGER(logger, "unity.dash.preview.precacher");
+
+const std::string PREVIEW_IDLE = "preview-idle";
+const std::string CACHE_IDLE = "cache-idle";
+
+const unsigned int CACHE_TIMEOUT = 100;
+
+PreviewPreCacher::PreviewPreCacher(Lens::Ptr const& lens, int cache_range)
+: lens_(lens)
+, cache_center_(0)
+, cache_delta_(0)
+, precaching_completeness(0)
+, cache_range_(cache_range)
+, category_index_(-1)
+, cache_cancel_(g_cancellable_new())
+{
+  if (lens_)
+  {
+    lens_->preview_ready.connect(sigc::mem_fun(this, &PreviewPreCacher::CenterPreview));
+
+    Categories::Ptr categories = lens_->categories;
+    categories->category_added.connect([&](Category const& category) {OnLensCategoryUpdated();});
+    categories->category_removed.connect([&](Category const& category) {OnLensCategoryUpdated();});
+  }
+}
+
+PreviewPreCacher::~PreviewPreCacher()
+{
+}
+
+void PreviewPreCacher::OnLensCategoryUpdated()
+{
+  if (category_index_ == -1)
+    return;
+  if (lens_)
+    result_model_ = lens_->GetFilterModelForCategory(category_index_);
+}
+
+void PreviewPreCacher::UpdateCategory(int category_index)
+{
+  if (category_index_ != category_index)
+  {
+    category_index_ = category_index;
+    ClearCache();
+    OnLensCategoryUpdated();
+  }
+}
+
+void PreviewPreCacher::Preview(std::string const& uri, int category_index)
+{
+  UpdateCategory(category_index);
+
+  if (preview_cancel_)
+    g_cancellable_cancel (preview_cancel_);
+  preview_cancel_ = g_cancellable_new ();
+
+  auto iter = preview_uri_cache_.find(uri);
+  if (iter != preview_uri_cache_.end())
+  {
+    Preview::Ptr preview(iter->second);
+    sources_.Remove(PREVIEW_IDLE);
+    sources_.AddIdle([&, uri, preview]()
+    {
+      preview_ready.emit(uri, preview);
+
+      // set the current center point.
+      ResetPreCachePosition(GetResultIndexForUri(uri));
+      return FALSE;
+    }, PREVIEW_IDLE);
+  }
+  else if (lens_)
+  { 
+    lens_->Preview(uri, preview_cancel_, sigc::mem_fun(this, &PreviewPreCacher::CenterPreview));
+  }
+}
+
+void PreviewPreCacher::ClearCache()
+{
+  if (cache_cancel_)
+    g_cancellable_cancel (cache_cancel_);
+  cache_cancel_ = g_cancellable_new ();
+
+  preview_index_cache_.clear();
+  preview_uri_cache_.clear();
+}
+
+void PreviewPreCacher::CenterPreview(std::string const& uri, Preview::Ptr const& preview)
+{
+  // forward the signal.
+  preview_ready.emit(uri, preview);
+
+  if (category_index_ == -1)
+    return;
+
+  int index = GetResultIndexForUri(uri);
+  preview_index_cache_[index] = preview;
+  preview_uri_cache_[uri] = preview;
+  ResetPreCachePosition(index);
+}
+
+void PreviewPreCacher::RecvPreviewPreCache(std::string const& uri, Preview::Ptr const& preview)
+{
+  int index = GetResultIndexForUri(uri);
+
+  preview_index_cache_[index] = preview;
+  preview_uri_cache_[uri] = preview;
+  QueuePreCache();
+}
+
+void PreviewPreCacher::ResetPreCachePosition(int index)
+{
+  if (index < 0 || index >=(int)GetResultCount())
+    return;
+
+  cache_center_ = index;
+  cache_delta_ = 0;
+  precaching_completeness = 0;
+  QueuePreCache();
+}
+
+void PreviewPreCacher::QueuePreCache()
+{
+  sources_.AddTimeout(CACHE_TIMEOUT, [&]()
+  {
+    ContinuePreCaching();
+    return FALSE;
+  }, CACHE_IDLE);
+}
+
+void PreviewPreCacher::ContinuePreCaching()
+{
+  if (precaching_completeness > 1)
+  {
+    OnPreCacheComplete();
+    return;
+  }
+
+  if (cache_delta_ > 0)
+    cache_delta_ = -cache_delta_;
+  else
+    cache_delta_ = (-cache_delta_) +1;
+
+  int next_position = cache_center_ + cache_delta_;
+
+  // get min and max positions away from cache center position.
+  int min_range = cache_range_ < 0 ? 0 : std::max<int>(0, cache_center_ - cache_range_);
+  int max_range = cache_range_ < 0 ? GetResultCount() : std::min<int>(GetResultCount(), cache_center_ + cache_range_ + 1);
+
+  if (next_position < min_range || next_position >= max_range)
+  {
+    precaching_completeness++;
+    ContinuePreCaching();
+    return;
+  }
+  precaching_completeness=0;
+
+  auto iter = preview_index_cache_.find(next_position);
+  if (iter != preview_index_cache_.end())
+  {
+    // position in result may have changed.
+    std::string uri_at_next_position_current = GetUriForResultIndex(next_position);
+
+    auto iter_preview_from_uri = preview_uri_cache_.find(uri_at_next_position_current);
+    if (iter_preview_from_uri != preview_uri_cache_.end())
+    {
+      preview_index_cache_[next_position] = iter_preview_from_uri->second;
+    }
+    QueuePreCache();
+  }
+  else if (!ExecutePreCache(next_position, GetUriForResultIndex(next_position)))
+  {
+    QueuePreCache();  
+  }
+}
+
+void PreviewPreCacher::OnPreCacheComplete()
+{
+}
+
+bool PreviewPreCacher::ExecutePreCache(int index, std::string const& uri)
+{
+  auto iter = preview_uri_cache_.find(uri);
+  if (iter != preview_uri_cache_.end())
+  {
+    preview_index_cache_[index] = iter->second;
+    return false;
+  }
+
+  LOG_DEBUG(logger) << "Preview pre-cache for '" << uri << "'";
+  lens_->Preview(uri, cache_cancel_, sigc::mem_fun(this, &PreviewPreCacher::RecvPreviewPreCache));
+  return true;
+}
+
+unsigned int PreviewPreCacher::GetResultIndexForUri(std::string const& uri)
+{
+  unsigned int index = 0;
+  for (ResultIterator it(GetResultIteratorAtIndex(0)); !it.IsLast(); ++it)
+  {
+    if ((*it).uri == uri)
+      break;
+
+    index++;
+  }
+
+  return index;
+}
+
+std::string PreviewPreCacher::GetUriForResultIndex(unsigned int index)
+{
+  if (index >= GetResultCount())
+    return "";
+
+  return (*GetResultIteratorAtIndex(index)).uri();
+}
+
+unsigned int PreviewPreCacher::GetResultCount() const
+{
+  if (result_model_)
+  {
+    return dee_model_get_n_rows(result_model_);
+  }
+
+  return 0;
+}
+
+ResultIterator PreviewPreCacher::GetResultIteratorAtIndex(unsigned index)
+{
+  if (!lens_)
+    return ResultIterator(result_model_);
+
+  DeeModelIter* iter = NULL;
+  if (result_model_)
+  {
+    iter = index > 0 ? dee_model_get_iter_at_row(result_model_, index) :
+      dee_model_get_first_iter(result_model_);
+  }
+  return ResultIterator(result_model_, iter, lens_->results()->GetTag());
+}
+
+} // namespace previews
+} // namespace dash
+} // namespace unity
\ No newline at end of file

=== added file 'UnityCore/PreviewPreCacher.h'
--- UnityCore/PreviewPreCacher.h	1970-01-01 00:00:00 +0000
+++ UnityCore/PreviewPreCacher.h	2012-12-10 10:03:24 +0000
@@ -0,0 +1,94 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright 2012 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3, as
+ * published by the  Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the applicable version of the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of both the GNU Lesser General Public
+ * License version 3 along with this program.  If not, see
+ * <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Nick Dedekind <[e-mail]>
+ *
+ */
+
+#ifndef PREVIEW_PRECACHER_H
+#define PREVIEW_PRECACHER_H
+
+#include <functional>
+#include <memory>
+#include "Preview.h"
+#include "ResultIterator.h"
+#include "GLibSource.h"
+#include "Lens.h"
+
+namespace unity
+{
+namespace dash
+{
+
+namespace previews
+{
+
+class PreviewPreCacher
+{
+public:
+  typedef std::shared_ptr<PreviewPreCacher> Ptr;
+
+  PreviewPreCacher(Lens::Ptr const& lens, int cache_range);
+  virtual ~PreviewPreCacher();
+
+  void Preview(std::string const& uri, int category_index);
+  void ClearCache();
+
+  sigc::signal<void, std::string const&, Preview::Ptr const&> preview_ready;
+
+protected:
+  void CenterPreview(std::string const& uri, Preview::Ptr const& preview);
+  void RecvPreviewPreCache(std::string const& uri, Preview::Ptr const& preview);
+
+protected:
+  void ResetPreCachePosition(int index);
+  void ContinuePreCaching();
+
+  void UpdateCategory(int category_index);
+  void OnLensCategoryUpdated();
+  ResultIterator GetResultIteratorAtIndex(unsigned index);
+
+  virtual void QueuePreCache();
+  virtual bool ExecutePreCache(int index, std::string const& uri);
+  virtual void OnPreCacheComplete();
+
+  // result accessors
+  virtual unsigned int GetResultCount() const;
+  virtual unsigned int GetResultIndexForUri(std::string const& uri);
+  virtual std::string GetUriForResultIndex(unsigned int index);
+
+  Lens::Ptr lens_;
+  std::map<int, Preview::Ptr> preview_index_cache_;
+  std::map<std::string, Preview::Ptr> preview_uri_cache_;
+  int cache_center_;
+  int cache_delta_;
+  int precaching_completeness;
+  int cache_range_;
+
+  int category_index_;
+  glib::Object<DeeModel> result_model_;
+  glib::Object<GCancellable> preview_cancel_;
+  glib::Object<GCancellable> cache_cancel_;
+  glib::SourceManager sources_;
+};
+
+} // namespace previews
+} // namespace dash
+} // namespace unity
+
+#endif // PREVIEW_PRECACHER_H

=== modified file 'dash/DashView.cpp'
--- dash/DashView.cpp	2012-11-23 23:49:46 +0000
+++ dash/DashView.cpp	2012-12-10 10:03:24 +0000
@@ -407,8 +407,13 @@
   lenses_layout_ = new nux::VLayout();
   content_layout_->AddView(lenses_layout_, 1, nux::MINOR_POSITION_START);
 
-  home_view_ = new LensView(home_lens_, nullptr);
+  home_view_ = new LensView(home_lens_, nullptr, NUX_TRACKER_LOCATION);
   home_view_->uri_activated.connect(sigc::mem_fun(this, &DashView::OnUriActivated));
+  home_view_->RegisterForPreviews([&] (std::string const& uri, Preview::Ptr const& model)
+  {
+    LOG_DEBUG(logger) << "Got home preview for: " << uri;
+    preview_state_machine_.ActivatePreview(model); // this does not immediately display a preview - we now wait.
+  });
 
   AddChild(home_view_);
   active_lens_view_ = home_view_;
@@ -935,7 +940,7 @@
   std::string id = lens->id;
   lens_bar_->AddLens(lens);
 
-  LensView* view = new LensView(lens, search_bar_->show_filters());
+  LensView* view = new LensView(lens, search_bar_->show_filters(), NUX_TRACKER_LOCATION);
   AddChild(view);
   view->SetVisible(false);
   view->uri_activated.connect(sigc::mem_fun(this, &DashView::OnUriActivated));
@@ -957,7 +962,7 @@
   });
 
   // Hook up to the new preview infrastructure
-  lens->preview_ready.connect([&] (std::string const& uri, Preview::Ptr model)
+  view->RegisterForPreviews([&] (std::string const& uri, Preview::Ptr const& model)
   {
     LOG_DEBUG(logger) << "Got preview for: " << uri;
     preview_state_machine_.ActivatePreview(model); // this does not immediately display a preview - we now wait.

=== modified file 'dash/LensView.cpp'
--- dash/LensView.cpp	2012-11-26 16:09:53 +0000
+++ dash/LensView.cpp	2012-12-10 10:03:24 +0000
@@ -137,15 +137,8 @@
 
 NUX_IMPLEMENT_OBJECT_TYPE(LensView);
 
-LensView::LensView()
-  : nux::View(NUX_TRACKER_LOCATION)
-  , filters_expanded(false)
-  , can_refine_search(false)
-  , no_results_active_(false)
-{}
-
-LensView::LensView(Lens::Ptr lens, nux::Area* show_filters)
-  : nux::View(NUX_TRACKER_LOCATION)
+LensView::LensView(Lens::Ptr const& lens, nux::Area* show_filters, NUX_FILE_LINE_DECL)
+  : nux::View(NUX_FILE_LINE_PARAM)
   , filters_expanded(false)
   , can_refine_search(false)
   , lens_(lens)
@@ -153,6 +146,7 @@
   , no_results_active_(false)
   , last_expanded_group_(nullptr)
   , last_good_filter_model_(-1)
+  , preview_precacher_(new previews::PreviewPreCacher(lens, -1))
 {
   SetupViews(show_filters);
   SetupCategories();
@@ -207,6 +201,10 @@
 
 }
 
+LensView::~LensView()
+{
+}
+
 void LensView::SetupViews(nux::Area* show_filters)
 {
   dash::Style& style = dash::Style::Instance();
@@ -366,7 +364,7 @@
   grid->expanded = false;
 
   group->SetRendererName(renderer_name.c_str());
-  grid->UriActivated.connect(sigc::bind([&] (std::string const& uri, ResultView::ActivateType type, GVariant* data, std::string const& view_id) 
+  grid->UriActivated.connect(sigc::bind([&] (std::string const& uri, ResultView::ActivateType type, GVariant* data, std::string const& view_id, int catgory_index) 
   {
     uri_activated.emit(type, uri, data, view_id); 
     switch (type)
@@ -377,13 +375,12 @@
       } break;
       case ResultView::ActivateType::PREVIEW:
       {
-        lens_->Preview(uri);
+        preview_precacher_->Preview(uri, catgory_index);
       } break;
       default: break;
     };
 
-  }, unique_id));
-
+  }, unique_id, category.index.Get()));
 
   /* Set up filter model for this category */
   Results::Ptr results_model = lens_->results;
@@ -793,6 +790,11 @@
   }
 }
 
+sigc::connection LensView::RegisterForPreviews(PreviewCallback const& callback)
+{
+  return preview_precacher_->preview_ready.connect(callback);
+}
+
 // Keyboard navigation
 bool LensView::AcceptKeyNavFocus()
 {

=== modified file 'dash/LensView.h'
--- dash/LensView.h	2012-11-14 08:57:56 +0000
+++ dash/LensView.h	2012-12-10 10:03:24 +0000
@@ -29,6 +29,7 @@
 #include <Nux/VLayout.h>
 #include <UnityCore/Lens.h>
 #include <UnityCore/GLibSource.h>
+#include "UnityCore/PreviewPreCacher.h"
 
 #include "FilterBar.h"
 #include "unity-shared/Introspectable.h"
@@ -50,8 +51,8 @@
   typedef std::map<PlacesGroup*, unsigned int> ResultCounts;
 
 public:
-  LensView();
-  LensView(Lens::Ptr lens, nux::Area* show_filters);
+  LensView(Lens::Ptr const& lens, nux::Area* show_filters, NUX_FILE_LINE_DECL);
+  ~LensView();
 
   CategoryGroups& categories() { return categories_; }
   FilterBar* filter_bar() const { return filter_bar_; }
@@ -75,6 +76,8 @@
   void CheckCategoryExpansion();
   void HideResultsMessage();
 
+  sigc::connection RegisterForPreviews(PreviewCallback const& callback);
+
 private:
   void SetupViews(nux::Area* show_filters);
   void SetupCategories();
@@ -124,9 +127,10 @@
   nux::StaticCairoText* no_results_;
 
   UBusManager ubus_manager_;
-  glib::Source::UniquePtr model_updated_timeout_;
+  glib::Source::UniquePtr model_updated_timeout_; 
   int last_good_filter_model_;
   glib::Source::UniquePtr fix_filter_models_idle_;
+  previews::PreviewPreCacher::Ptr preview_precacher_;
 };
 
 

=== modified file 'dash/previews/ApplicationPreview.cpp'
--- dash/previews/ApplicationPreview.cpp	2012-11-26 16:09:53 +0000
+++ dash/previews/ApplicationPreview.cpp	2012-12-10 10:03:24 +0000
@@ -305,11 +305,11 @@
   nux::Geometry geo_art(geo.x, geo.y, style.GetAppImageAspectRatio() * geo.height, geo.height);
 
   if (geo.width - geo_art.width - style.GetPanelSplitWidth() - style.GetDetailsLeftMargin() - style.GetDetailsRightMargin() < style.GetDetailsPanelMinimumWidth())
-    geo_art.width = MAX(0, geo.width - style.GetPanelSplitWidth() - style.GetDetailsLeftMargin() - style.GetDetailsRightMargin() - style.GetDetailsPanelMinimumWidth());
+    geo_art.width = std::max(0, geo.width - style.GetPanelSplitWidth() - style.GetDetailsLeftMargin() - style.GetDetailsRightMargin() - style.GetDetailsPanelMinimumWidth());
   image_->SetMinMaxSize(geo_art.width, geo_art.height);
 
-  int details_width = MAX(0, geo.width - geo_art.width - style.GetPanelSplitWidth() - style.GetDetailsLeftMargin() - style.GetDetailsRightMargin());
-  int top_app_info_max_width = MAX(0, details_width - style.GetAppIconAreaWidth() - style.GetSpaceBetweenIconAndDetails());
+  int details_width = std::max(0, geo.width - geo_art.width - style.GetPanelSplitWidth() - style.GetDetailsLeftMargin() - style.GetDetailsRightMargin());
+  int top_app_info_max_width = std::max(0, details_width - style.GetAppIconAreaWidth() - style.GetSpaceBetweenIconAndDetails());
 
   if (title_) { title_->SetMaximumWidth(top_app_info_max_width); }
   if (subtitle_) { subtitle_->SetMaximumWidth(top_app_info_max_width); }

=== modified file 'dash/previews/GenericPreview.cpp'
--- dash/previews/GenericPreview.cpp	2012-11-13 21:42:58 +0000
+++ dash/previews/GenericPreview.cpp	2012-12-10 10:03:24 +0000
@@ -232,10 +232,10 @@
   nux::Geometry geo_art(geo.x, geo.y, style.GetAppImageAspectRatio() * geo.height, geo.height);
 
   if (geo.width - geo_art.width - style.GetPanelSplitWidth() - style.GetDetailsLeftMargin() - style.GetDetailsRightMargin() < style.GetDetailsPanelMinimumWidth())
-    geo_art.width = MAX(0, geo.width - style.GetPanelSplitWidth() - style.GetDetailsLeftMargin() - style.GetDetailsRightMargin() - style.GetDetailsPanelMinimumWidth());
+    geo_art.width = std::max(0, geo.width - style.GetPanelSplitWidth() - style.GetDetailsLeftMargin() - style.GetDetailsRightMargin() - style.GetDetailsPanelMinimumWidth());
   image_->SetMinMaxSize(geo_art.width, geo_art.height);
 
-  int details_width = MAX(0, geo.width - geo_art.width - style.GetPanelSplitWidth() - style.GetDetailsLeftMargin() - style.GetDetailsRightMargin());
+  int details_width = std::max(0, geo.width - geo_art.width - style.GetPanelSplitWidth() - style.GetDetailsLeftMargin() - style.GetDetailsRightMargin());
 
   if (title_) { title_->SetMaximumWidth(details_width); }
   if (subtitle_) { subtitle_->SetMaximumWidth(details_width); }

=== modified file 'dash/previews/MoviePreview.cpp'
--- dash/previews/MoviePreview.cpp	2012-11-13 21:42:58 +0000
+++ dash/previews/MoviePreview.cpp	2012-12-10 10:03:24 +0000
@@ -250,10 +250,10 @@
   nux::Geometry geo_art(geo.x, geo.y, style.GetVideoImageAspectRatio() * geo.height, geo.height);
 
   if (geo.width - geo_art.width - style.GetPanelSplitWidth() - style.GetDetailsLeftMargin() - style.GetDetailsRightMargin() < style.GetDetailsPanelMinimumWidth())
-    geo_art.width = MAX(0, geo.width - style.GetPanelSplitWidth() - style.GetDetailsLeftMargin() - style.GetDetailsRightMargin() - style.GetDetailsPanelMinimumWidth());
+    geo_art.width = std::max(0, geo.width - style.GetPanelSplitWidth() - style.GetDetailsLeftMargin() - style.GetDetailsRightMargin() - style.GetDetailsPanelMinimumWidth());
   image_->SetMinMaxSize(geo_art.width, geo_art.height);
 
-  int details_width = MAX(0, geo.width - geo_art.width - style.GetPanelSplitWidth() - style.GetDetailsLeftMargin() - style.GetDetailsRightMargin());
+  int details_width = std::max(0, geo.width - geo_art.width - style.GetPanelSplitWidth() - style.GetDetailsLeftMargin() - style.GetDetailsRightMargin());
 
   if (title_) { title_->SetMaximumWidth(details_width); }
   if (subtitle_) { subtitle_->SetMaximumWidth(details_width); }

=== modified file 'dash/previews/MusicPreview.cpp'
--- dash/previews/MusicPreview.cpp	2012-11-06 18:19:09 +0000
+++ dash/previews/MusicPreview.cpp	2012-12-10 10:03:24 +0000
@@ -264,10 +264,10 @@
   nux::Geometry geo_art(geo.x, geo.y, style.GetAppImageAspectRatio() * geo.height, geo.height);
 
   if (geo.width - geo_art.width - style.GetPanelSplitWidth() - style.GetDetailsLeftMargin() - style.GetDetailsRightMargin() < style.GetDetailsPanelMinimumWidth())
-    geo_art.width = MAX(0, geo.width - style.GetPanelSplitWidth() - style.GetDetailsLeftMargin() - style.GetDetailsRightMargin() - style.GetDetailsPanelMinimumWidth());
+    geo_art.width = std::max(0, geo.width - style.GetPanelSplitWidth() - style.GetDetailsLeftMargin() - style.GetDetailsRightMargin() - style.GetDetailsPanelMinimumWidth());
   image_->SetMinMaxSize(geo_art.width, geo_art.height);
 
-  int details_width = MAX(0, geo.width - geo_art.width - style.GetPanelSplitWidth() - style.GetDetailsLeftMargin() - style.GetDetailsRightMargin());
+  int details_width = std::max(0, geo.width - geo_art.width - style.GetPanelSplitWidth() - style.GetDetailsLeftMargin() - style.GetDetailsRightMargin());
 
   if (title_) { title_->SetMaximumWidth(details_width); }
   if (subtitle_) { subtitle_->SetMaximumWidth(details_width); }

=== modified file 'dash/previews/PreviewContainer.cpp'
--- dash/previews/PreviewContainer.cpp	2012-11-30 20:22:13 +0000
+++ dash/previews/PreviewContainer.cpp	2012-12-10 10:03:24 +0000
@@ -412,7 +412,7 @@
 
 void PreviewContainer::Preview(dash::Preview::Ptr preview_model, Navigation direction)
 {
-  previews::Preview::Ptr preview_view = previews::Preview::PreviewForModel(preview_model);
+  previews::Preview::Ptr preview_view = preview_model ? previews::Preview::PreviewForModel(preview_model) : previews::Preview::Ptr();
   
   if (preview_view)
   {

=== modified file 'dash/previews/PreviewInfoHintWidget.cpp'
--- dash/previews/PreviewInfoHintWidget.cpp	2012-11-06 18:19:09 +0000
+++ dash/previews/PreviewInfoHintWidget.cpp	2012-12-10 10:03:24 +0000
@@ -209,7 +209,7 @@
   int info_value_width = geo.width;
   info_value_width -= layout_spacing;
   info_value_width -= info_hint_width;
-  info_value_width = MAX(0, info_value_width);
+  info_value_width = std::max(0, info_value_width);
 
   for (InfoHint const& info_hint : info_hints_)
   {

=== modified file 'dash/previews/SocialPreview.cpp'
--- dash/previews/SocialPreview.cpp	2012-11-26 16:09:53 +0000
+++ dash/previews/SocialPreview.cpp	2012-12-10 10:03:24 +0000
@@ -281,12 +281,12 @@
   nux::Geometry geo_content(geo.x, geo.y, style.GetAppImageAspectRatio() * geo.height, geo.height);
 
   if (geo.width - geo_content.width - style.GetPanelSplitWidth() - style.GetDetailsLeftMargin() - style.GetDetailsRightMargin() < style.GetDetailsPanelMinimumWidth())
-    geo_content.width = MAX(0, geo.width - style.GetPanelSplitWidth() - style.GetDetailsLeftMargin() - style.GetDetailsRightMargin() - style.GetDetailsPanelMinimumWidth());
+    geo_content.width = std::max(0, geo.width - style.GetPanelSplitWidth() - style.GetDetailsLeftMargin() - style.GetDetailsRightMargin() - style.GetDetailsPanelMinimumWidth());
   if (content_) { content_->SetMinMaxSize(geo_content.width, geo_content.height); }
   if (image_) { image_->SetMinMaxSize(geo_content.width, geo_content.height); }
 
-  int details_width = MAX(0, geo.width - geo_content.width - style.GetPanelSplitWidth() - style.GetDetailsLeftMargin() - style.GetDetailsRightMargin());
-  int top_social_info_max_width = details_width - style.GetAppIconAreaWidth() - style.GetSpaceBetweenIconAndDetails();
+  int details_width = std::max(0, geo.width - geo_content.width - style.GetPanelSplitWidth() - style.GetDetailsLeftMargin() - style.GetDetailsRightMargin());
+  int top_social_info_max_width = std::max(details_width - style.GetAppIconAreaWidth() - style.GetSpaceBetweenIconAndDetails(), 0);
 
   if (title_) { title_->SetMaximumWidth(top_social_info_max_width); }
   if (subtitle_) { subtitle_->SetMaximumWidth(top_social_info_max_width); }

=== modified file 'dash/previews/SocialPreviewComments.cpp'
--- dash/previews/SocialPreviewComments.cpp	2012-11-08 09:12:24 +0000
+++ dash/previews/SocialPreviewComments.cpp	2012-12-10 10:03:24 +0000
@@ -102,7 +102,7 @@
     }
   }
 
-  int comment_value_width = MAX(0, geo.width - style.GetDetailsLeftMargin() - style.GetDetailsRightMargin());
+  int comment_value_width = std::max(0, geo.width - style.GetDetailsLeftMargin() - style.GetDetailsRightMargin());
 
   for (Comment const& comment : comments_)
   {

=== modified file 'dash/previews/SocialPreviewContent.cpp'
--- dash/previews/SocialPreviewContent.cpp	2012-11-16 19:22:31 +0000
+++ dash/previews/SocialPreviewContent.cpp	2012-12-10 10:03:24 +0000
@@ -149,8 +149,8 @@
 
   nux::Geometry geo_cr(GetBubbleGeometry(geo));
 
-  int max_width = geo_cr.width - 2*(geo_cr.width*0.1);
-  int max_height = (geo_cr.height - TAIL_HEIGHT) - 2*((geo_cr.height - TAIL_HEIGHT)*0.1);
+  int max_width = std::max(0, (int)(geo_cr.width - 2*(geo_cr.width*0.1)));
+  int max_height = std::max(0, (int)((geo_cr.height - TAIL_HEIGHT) - 2*((geo_cr.height - TAIL_HEIGHT)*0.1)));
 
   // this will update the texture with the actual size of the text.
   text_->SetMaximumHeight(max_height);
@@ -169,8 +169,8 @@
 
 void SocialPreviewContent::RedrawBubble(nux::Geometry const& geom, cairo_t* cr, nux::ButtonVisualState faked_state)
 {
-  double width = MAX(0, cairo_image_surface_get_width(cairo_get_target(cr)));
-  double height = MAX(0, cairo_image_surface_get_height(cairo_get_target(cr)) - TAIL_HEIGHT);
+  double width = std::max(0, cairo_image_surface_get_width(cairo_get_target(cr)));
+  double height = std::max(0, cairo_image_surface_get_height(cairo_get_target(cr)) - TAIL_HEIGHT);
 
   double tailPosition = width - TAIL_POS_FROM_RIGHT - TAIL_HEIGHT;
   if (width > 0 && height > 0)

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2012-12-05 09:10:04 +0000
+++ tests/CMakeLists.txt	2012-12-10 10:03:24 +0000
@@ -130,6 +130,7 @@
        test_layout_system.cpp
        test_model_iterator.cpp
        test_previews.cpp
+       test_previews_precacher.cpp
        test_time_util.cpp
        test_ubus.cpp
        test_unityshell_private.cpp

=== modified file 'tests/test_lens.cpp'
--- tests/test_lens.cpp	2012-11-14 08:57:56 +0000
+++ tests/test_lens.cpp	2012-12-10 10:03:24 +0000
@@ -228,9 +228,7 @@
     previewed = true;
   };
 
-  lens_->preview_ready.connect(preview_cb);
-
-  lens_->Preview(uri);
+  lens_->Preview(uri, NULL, preview_cb);
   Utils::WaitUntil(previewed);
 }
 
@@ -251,8 +249,7 @@
     previewed = true;
   };
 
-  lens_->preview_ready.connect(preview_cb);
-  lens_->Preview(uri);
+  lens_->Preview(uri, NULL, preview_cb);
 
   Utils::WaitUntil(previewed);
 
@@ -290,8 +287,7 @@
     previewed = true;
   };
 
-  lens_->preview_ready.connect(preview_cb);
-  lens_->Preview(uri);
+  lens_->Preview(uri, NULL, preview_cb);
 
   Utils::WaitUntil(previewed);
 
@@ -336,7 +332,7 @@
   };
 
   lens_->preview_ready.connect(preview_cb);
-  lens_->Preview(uri);
+  lens_->Preview(uri, NULL, std::nullptr_t());
 
   Utils::WaitUntil(previewed);
 }

=== added file 'tests/test_previews_precacher.cpp'
--- tests/test_previews_precacher.cpp	1970-01-01 00:00:00 +0000
+++ tests/test_previews_precacher.cpp	2012-12-10 10:03:24 +0000
@@ -0,0 +1,224 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2012 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Nick Dedekind <[e-mail]>
+ */
+
+#include <list>
+#include <gmock/gmock.h>
+using namespace testing;
+
+#include <Nux/Nux.h>
+
+#include "UnityCore/PreviewPreCacher.h"
+
+using namespace unity;
+using namespace unity::dash;
+
+namespace
+{
+
+class MockPreviewPreCacher : public previews::PreviewPreCacher
+{
+public:
+  MockPreviewPreCacher(int cache_range)
+  : PreviewPreCacher(NULL, cache_range)
+  , queue_(true)
+  {
+    ON_CALL (*this, GetResultCount()).WillByDefault(Return(10));
+    ON_CALL (*this, GetUriForResultIndex(_)).WillByDefault(Return("preview"));
+    ON_CALL (*this, ExecutePreCache(_,_)).WillByDefault(Return(true));
+  }
+
+  MOCK_CONST_METHOD0 (GetResultCount, unsigned int());
+  MOCK_METHOD1 (GetUriForResultIndex, std::string(int));
+  MOCK_METHOD2 (ExecutePreCache, bool(int, std::string const&));
+  MOCK_METHOD0 (OnPreCacheComplete, void());
+
+  void enable_queue() { queue_ = true; }
+  void disable_queue() { queue_ = false; }
+
+  // mock this method so we dont have to wait on idle.
+  virtual void QueuePreCache()
+  {
+    if (queue_)
+    {
+      PreviewPreCacher::QueuePreCache();
+    }
+    else
+    {
+      ContinuePreCaching();
+    }
+  }
+
+  using PreviewPreCacher::ResetPreCachePosition;
+  using PreviewPreCacher::ContinuePreCaching;
+
+private:
+  bool queue_;
+};
+
+
+TEST(TestPreviewPreCacher, TestMathCenterInside)
+{
+  NiceMock<MockPreviewPreCacher> cacher(10);
+  cacher.disable_queue();
+
+  EXPECT_CALL(cacher, ExecutePreCache(4,_)).Times(1);
+  cacher.ResetPreCachePosition(3);
+ 
+  EXPECT_CALL(cacher, ExecutePreCache(2,_)).Times(1);
+  cacher.ContinuePreCaching();
+
+  EXPECT_CALL(cacher, ExecutePreCache(5,_)).Times(1);
+  cacher.ContinuePreCaching();
+
+  EXPECT_CALL(cacher, ExecutePreCache(1,_)).Times(1);
+  cacher.ContinuePreCaching();
+
+  EXPECT_CALL(cacher, ExecutePreCache(6,_)).Times(1);
+  cacher.ContinuePreCaching();
+
+  EXPECT_CALL(cacher, ExecutePreCache(0,_)).Times(1);
+  cacher.ContinuePreCaching();
+
+  EXPECT_CALL(cacher, ExecutePreCache(7,_)).Times(1);
+  cacher.ContinuePreCaching();
+
+  EXPECT_CALL(cacher, ExecutePreCache(8,_)).Times(1);
+  cacher.ContinuePreCaching();
+
+  EXPECT_CALL(cacher, ExecutePreCache(9,_)).Times(1);
+  cacher.ContinuePreCaching();
+
+  EXPECT_CALL(cacher, OnPreCacheComplete());
+  cacher.ContinuePreCaching();
+}
+
+TEST(TestPreviewPreCacher, TestMathCenterOutsidePositive)
+{
+  NiceMock<MockPreviewPreCacher> cacher(10);
+  cacher.disable_queue();
+
+  EXPECT_CALL(cacher, ExecutePreCache(_,_)).Times(0);
+  cacher.ResetPreCachePosition(11);
+}
+
+TEST(TestPreviewPreCacher, TestMathCenterOutsideNegative)
+{
+  NiceMock<MockPreviewPreCacher> cacher(10);
+  cacher.disable_queue();
+
+  EXPECT_CALL(cacher, ExecutePreCache(_,_)).Times(0);
+  cacher.ResetPreCachePosition(-1);
+}
+
+TEST(TestPreviewPreCacher, TestMathCenterBoundaryZero)
+{
+  NiceMock<MockPreviewPreCacher> cacher(10);
+  cacher.disable_queue();
+
+  EXPECT_CALL(cacher, ExecutePreCache(1,_)).Times(1);
+  cacher.ResetPreCachePosition(0);
+
+  for (int i = 1; i < (int)cacher.GetResultCount()-1; i++)
+  {
+    EXPECT_CALL(cacher, ExecutePreCache(i+1,_)).Times(1);
+    cacher.ContinuePreCaching();
+  }
+
+  EXPECT_CALL(cacher, OnPreCacheComplete());
+  cacher.ContinuePreCaching();
+}
+
+TEST(TestPreviewPreCacher, TestMathCenterBoundaryCount)
+{
+  NiceMock<MockPreviewPreCacher> cacher(10);
+  cacher.disable_queue();
+
+  EXPECT_CALL(cacher, ExecutePreCache(_,_)).Times(0);
+  cacher.ResetPreCachePosition(cacher.GetResultCount());
+}
+
+TEST(TestPreviewPreCacher, TestMathRangedCenterBottom)
+{
+  NiceMock<MockPreviewPreCacher> cacher(3);
+  cacher.disable_queue();
+
+  EXPECT_CALL(cacher, ExecutePreCache(2,_)).Times(1);
+  cacher.ResetPreCachePosition(1);
+
+  EXPECT_CALL(cacher, ExecutePreCache(0,_)).Times(1);
+  cacher.ContinuePreCaching();
+
+  EXPECT_CALL(cacher, ExecutePreCache(3,_)).Times(1);
+  cacher.ContinuePreCaching();
+
+  EXPECT_CALL(cacher, ExecutePreCache(4,_)).Times(1);
+  cacher.ContinuePreCaching();
+
+  EXPECT_CALL(cacher, ExecutePreCache(5,_)).Times(0);
+  EXPECT_CALL(cacher, OnPreCacheComplete());
+  cacher.ContinuePreCaching();
+}
+
+TEST(TestPreviewPreCacher, TestMathRangedCenterMiddle)
+{
+  NiceMock<MockPreviewPreCacher> cacher(2);
+  cacher.disable_queue();
+
+  EXPECT_CALL(cacher, ExecutePreCache(6,_)).Times(1);
+  cacher.ResetPreCachePosition(5);
+
+  EXPECT_CALL(cacher, ExecutePreCache(4,_)).Times(1);
+  cacher.ContinuePreCaching();
+
+  EXPECT_CALL(cacher, ExecutePreCache(7,_)).Times(1);
+  cacher.ContinuePreCaching();
+
+  EXPECT_CALL(cacher, ExecutePreCache(3,_)).Times(1);
+  cacher.ContinuePreCaching();
+
+  EXPECT_CALL(cacher, ExecutePreCache(8,_)).Times(0);
+  EXPECT_CALL(cacher, OnPreCacheComplete());
+  cacher.ContinuePreCaching();
+}
+
+TEST(TestPreviewPreCacher, TestMathRangedCenterTop)
+{
+  NiceMock<MockPreviewPreCacher> cacher(3);
+  cacher.disable_queue();
+
+  EXPECT_CALL(cacher, ExecutePreCache(9,_)).Times(1);
+  cacher.ResetPreCachePosition(8);
+
+  EXPECT_CALL(cacher, ExecutePreCache(7,_)).Times(1);
+  cacher.ContinuePreCaching();
+
+  EXPECT_CALL(cacher, ExecutePreCache(6,_)).Times(1);
+  cacher.ContinuePreCaching();
+
+  EXPECT_CALL(cacher, ExecutePreCache(5,_)).Times(1);
+  cacher.ContinuePreCaching();
+
+  EXPECT_CALL(cacher, ExecutePreCache(4,_)).Times(0);
+  EXPECT_CALL(cacher, OnPreCacheComplete());
+  cacher.ContinuePreCaching();
+}
+
+
+
+}