Merge lp:~mhr3/unity/fix-929506 into lp:unity

[Michal Hruby]

Splits out the .lens file reading out of FilesystemLenses class and exposes it in LensDirectoryReader, this allows the BFB to directly check the lens files from the disk and we don't start up the lenses as soon as unity starts.

Un-reverts the revert done in r2001.

The extremely complex part for unity-2d is @ https://code.launchpad.net/~mhr3/unity-2d/default-filesystemlenses-constructor/+merge/94102

Covered by existing tests.

[Mikkel Kamstrup Erlandsen (kamstrup)]

I think you need to fix the right click on the bfb in order for this to be acceptable. It is not entirely unlikely that this could be a user's first interaction...

review: Needs Fixing

[Michal Hruby (mhr3)]

Of course, the first attempt was to do it without an API/ABI break, this time it's with ABI break.

[Gord Allott (gordallott)]

Works well and the test suite we have covering the filesystemlens object passes perfectly, approving

review: Approve

[Gord Allott (gordallott)]

review: Approve

=== modified file 'UnityCore/FilesystemLenses.cpp'
--- UnityCore/FilesystemLenses.cpp	2012-02-21 21:36:27 +0000
+++ UnityCore/FilesystemLenses.cpp	2012-02-22 08:58:25 +0000
@@ -46,39 +46,33 @@
 }
 
 // Loads data from a Lens key-file in a usable form
-struct LensFileData
+LensDirectoryReader::LensFileData::LensFileData(GKeyFile* file, 
+                                                const gchar *lens_id)
+  : id(g_strdup(lens_id))
+  , domain(g_key_file_get_string(file, G_KEY_FILE_DESKTOP_GROUP, "X-Ubuntu-Gettext-Domain", NULL))
+  , dbus_name(g_key_file_get_string(file, GROUP, "DBusName", NULL))
+  , dbus_path(g_key_file_get_string(file, GROUP, "DBusPath", NULL))
+  , name(g_strdup(g_dgettext(domain.Value(), g_key_file_get_string(file, GROUP, "Name", NULL))))
+  , icon(g_key_file_get_string(file, GROUP, "Icon", NULL))
+  , description(g_key_file_get_locale_string(file, GROUP, "Description", NULL, NULL))
+  , search_hint(g_key_file_get_locale_string(file, GROUP, "SearchHint", NULL, NULL))
+  , visible(true)
+  , shortcut(g_key_file_get_string(file, GROUP, "Shortcut", NULL))
 {
-  LensFileData(GKeyFile* file)
-    : domain(g_key_file_get_string(file, G_KEY_FILE_DESKTOP_GROUP, "X-Ubuntu-Gettext-Domain", NULL))
-    , dbus_name(g_key_file_get_string(file, GROUP, "DBusName", NULL))
-    , dbus_path(g_key_file_get_string(file, GROUP, "DBusPath", NULL))
-    , name(g_strdup(g_dgettext(domain.Value(), g_key_file_get_string(file, GROUP, "Name", NULL))))
-    , icon(g_key_file_get_string(file, GROUP, "Icon", NULL))
-    , description(g_key_file_get_locale_string(file, GROUP, "Description", NULL, NULL))
-    , search_hint(g_key_file_get_locale_string(file, GROUP, "SearchHint", NULL, NULL))
-    , visible(g_key_file_get_boolean(file, GROUP, "Visible", NULL))
-    , shortcut(g_key_file_get_string(file, GROUP, "Shortcut", NULL))
-  {}
-
-  static bool IsValid(GKeyFile* file, glib::Error& error)
+  if (g_key_file_has_key(file, GROUP, "Visible", NULL))
   {
-    return (g_key_file_has_group(file, GROUP) &&
-            g_key_file_has_key(file, GROUP, "DBusName", &error) &&
-            g_key_file_has_key(file, GROUP, "DBusPath", &error) &&
-            g_key_file_has_key(file, GROUP, "Name", &error) &&
-            g_key_file_has_key(file, GROUP, "Icon", &error));
+    visible = g_key_file_get_boolean(file, GROUP, "Visible", NULL) != FALSE;
   }
+}
 
-  glib::String domain;
-  glib::String dbus_name;
-  glib::String dbus_path;
-  glib::String name;
-  glib::String icon;
-  glib::String description;
-  glib::String search_hint;
-  bool         visible;
-  glib::String shortcut;
-};
+bool LensDirectoryReader::LensFileData::IsValid(GKeyFile* file, glib::Error& error)
+{
+  return (g_key_file_has_group(file, GROUP) &&
+          g_key_file_has_key(file, GROUP, "DBusName", &error) &&
+          g_key_file_has_key(file, GROUP, "DBusPath", &error) &&
+          g_key_file_has_key(file, GROUP, "Name", &error) &&
+          g_key_file_has_key(file, GROUP, "Icon", &error));
+}
 
 /* A quick guide to finding Lens files
  *
@@ -103,92 +97,57 @@
  * override those found system-wide. This is to ease development of Lenses.
  *
  */
-class FilesystemLenses::Impl
+
+class LensDirectoryReader::Impl
 {
 public:
   typedef std::map<GFile*, glib::Object<GCancellable>> CancellableMap;
 
-  Impl(FilesystemLenses* owner);
-  Impl(FilesystemLenses* owner, std::string const& lens_directory);
-
-  ~Impl();
-
-  LensList GetLenses() const;
-  Lens::Ptr GetLens(std::string const& lens_id) const;
-  Lens::Ptr GetLensAtIndex(std::size_t index) const;
-  Lens::Ptr GetLensForShortcut(std::string const& lens_shortcut) const;
-  std::size_t count() const;
-
-  void Init();
-  glib::Object<GFile> BuildLensPathFile(std::string const& directory);
+  Impl(LensDirectoryReader *owner, std::string const& directory)
+    : owner_(owner)
+    , directory_(g_file_new_for_path(directory.c_str()))
+    , children_waiting_to_load_(0)
+    , enumeration_done_(false)
+  {
+    LOG_DEBUG(logger) << "Initialising lens reader for: " << directory;
+
+    glib::Object<GCancellable> cancellable(g_cancellable_new());
+    g_file_enumerate_children_async(directory_,
+                                    G_FILE_ATTRIBUTE_STANDARD_NAME,
+                                    G_FILE_QUERY_INFO_NONE,
+                                    G_PRIORITY_DEFAULT,
+                                    cancellable,
+                                    (GAsyncReadyCallback)OnDirectoryEnumerated,
+                                    this);
+    cancel_map_[directory_] = cancellable;
+  }
+
+  ~Impl()
+  {
+    for (auto pair: cancel_map_)
+    {
+      g_cancellable_cancel(pair.second);
+    }
+  }
+
   void EnumerateLensesDirectoryChildren(GFileEnumerator* enumerator);
   void LoadLensFile(std::string const& lensfile_path);
-  void CreateLensFromKeyFileData(GFile* path, const char* data, gsize length);
-  void DecrementAndCheckChildrenWaiting();
+  void GetLensDataFromKeyFile(GFile* path, const char* data, gsize length);
+  DataList GetLensData() const;
+  void SortLensList();
   
   static void OnDirectoryEnumerated(GFile* source, GAsyncResult* res, Impl* self);
   static void LoadFileContentCallback(GObject* source, GAsyncResult* res, gpointer user_data);
 
-  FilesystemLenses* owner_;
+  LensDirectoryReader *owner_;
   glib::Object<GFile> directory_;
+  DataList lenses_data_;
   std::size_t children_waiting_to_load_;
+  bool enumeration_done_;
   CancellableMap cancel_map_;
-  LensList lenses_;
 };
 
-FilesystemLenses::Impl::Impl(FilesystemLenses* owner)
-  : owner_(owner)
-  , children_waiting_to_load_(0)
-{
-  LOG_DEBUG(logger) << "Initialising in standard lens directory mode: " << LENSES_DIR;
-
-  directory_ = BuildLensPathFile(LENSES_DIR);
-
-  Init();
-}
-
-FilesystemLenses::Impl::Impl(FilesystemLenses* owner, std::string const& lens_directory)
-  : owner_(owner)
-  , children_waiting_to_load_(0)
-{
-  LOG_DEBUG(logger) << "Initialising in override lens directory mode";
-
-  directory_ = g_file_new_for_path(lens_directory.c_str());
-
-  Init();
-}
-
-FilesystemLenses::Impl::~Impl()
-{
-  for (auto pair: cancel_map_)
-  {
-    g_cancellable_cancel(pair.second);
-  }
-}
-
-void FilesystemLenses::Impl::Init()
-{
-  glib::String path(g_file_get_path(directory_));
-  LOG_DEBUG(logger) << "Searching for Lenses in: " << path;
-
-  glib::Object<GCancellable> cancellable(g_cancellable_new());
-  g_file_enumerate_children_async(directory_,
-                                  G_FILE_ATTRIBUTE_STANDARD_NAME,
-                                  G_FILE_QUERY_INFO_NONE,
-                                  G_PRIORITY_DEFAULT,
-                                  cancellable,
-                                  (GAsyncReadyCallback)OnDirectoryEnumerated,
-                                  this);
-  cancel_map_[directory_] = cancellable;
-}
-
-glib::Object<GFile> FilesystemLenses::Impl::BuildLensPathFile(std::string const& directory)
-{
-  glib::Object<GFile> file(g_file_new_for_path(directory.c_str()));
-  return file;
-}
-
-void FilesystemLenses::Impl::OnDirectoryEnumerated(GFile* source, GAsyncResult* res, Impl* self)
+void LensDirectoryReader::Impl::OnDirectoryEnumerated(GFile* source, GAsyncResult* res, Impl* self)
 {
   glib::Error error;
   glib::Object<GFileEnumerator> enumerator(g_file_enumerate_children_finish(source, res, error.AsOutParam()));
@@ -196,43 +155,59 @@
   if (error || !enumerator)
   {
     glib::String path(g_file_get_path(source));
-    LOG_WARN(logger) << "Unabled to enumerate children of directory "
+    LOG_WARN(logger) << "Unable to enumerate children of directory "
                      << path << " "
                      << error;
     return;
   }
+  self->cancel_map_.erase(source);
   self->EnumerateLensesDirectoryChildren(enumerator);
-  self->cancel_map_.erase(source);
 }
 
-void FilesystemLenses::Impl::EnumerateLensesDirectoryChildren(GFileEnumerator* enumerator)
+void LensDirectoryReader::Impl::EnumerateLensesDirectoryChildren(GFileEnumerator* in_enumerator)
 {
-  glib::Error error;
-  glib::Object<GFileInfo> info;
+  glib::Object<GCancellable> cancellable(g_cancellable_new());
 
-  while (info = g_file_enumerator_next_file(enumerator, NULL, error.AsOutParam()))
-  {
-    if (info && !error)
+  cancel_map_[g_file_enumerator_get_container(in_enumerator)] = cancellable;
+  g_file_enumerator_next_files_async (in_enumerator, 64, G_PRIORITY_DEFAULT,
+                                      cancellable,
+                                      [] (GObject *src, GAsyncResult *res,
+                                          gpointer data) -> void {
+    // async callback
+    glib::Error error;
+    GFileEnumerator *enumerator = G_FILE_ENUMERATOR (src);
+    // FIXME: won't this kill the enumerator?
+    GList *files = g_file_enumerator_next_files_finish (enumerator, res, error.AsOutParam());
+    if (!error)
     {
-      std::string name(g_file_info_get_name(info));
-      glib::String dir_path(g_file_get_path(g_file_enumerator_get_container(enumerator)));
-      std::string lensfile_name = name + ".lens";
-
-      glib::String lensfile_path(g_build_filename(dir_path.Value(),
-                                                  name.c_str(),
-                                                  lensfile_name.c_str(),
-                                                  NULL));
-      LoadLensFile(lensfile_path.Str());
+      Impl *self = (Impl*) data;
+      self->cancel_map_.erase(g_file_enumerator_get_container(enumerator));
+      for (GList *iter = files; iter; iter = iter->next)
+      {
+        glib::Object<GFileInfo> info((GFileInfo*) iter->data);
+
+        std::string name(g_file_info_get_name(info));
+        glib::String dir_path(g_file_get_path(g_file_enumerator_get_container(enumerator)));
+        std::string lensfile_name = name + ".lens";
+
+        glib::String lensfile_path(g_build_filename(dir_path.Value(),
+                                                    name.c_str(),
+                                                    lensfile_name.c_str(),
+                                                    NULL));
+        self->LoadLensFile(lensfile_path.Str());
+      }
+      // the GFileInfos got already freed during the iteration
+      g_list_free (files);
+      self->enumeration_done_ = true;
     }
     else
     {
       LOG_WARN(logger) << "Cannot enumerate over directory: " << error;
-      continue;
     }
-  }
+  }, this);
 }
 
-void FilesystemLenses::Impl::LoadLensFile(std::string const& lensfile_path)
+void LensDirectoryReader::Impl::LoadLensFile(std::string const& lensfile_path)
 {
   glib::Object<GFile> file(g_file_new_for_path(lensfile_path.c_str()));
   glib::Object<GCancellable> cancellable(g_cancellable_new());
@@ -242,14 +217,14 @@
 
   g_file_load_contents_async(file,
                              cancellable,
-                             (GAsyncReadyCallback)(FilesystemLenses::Impl::LoadFileContentCallback),
+                             (GAsyncReadyCallback)(LensDirectoryReader::Impl::LoadFileContentCallback),
                              this);
   cancel_map_[file] = cancellable;
 }
 
-void FilesystemLenses::Impl::LoadFileContentCallback(GObject* source,
-                                                     GAsyncResult* res,
-                                                     gpointer user_data)
+void LensDirectoryReader::Impl::LoadFileContentCallback(GObject* source,
+                                                        GAsyncResult* res,
+                                                        gpointer user_data)
 {
   Impl* self = static_cast<Impl*>(user_data);
   glib::Error error;
@@ -263,7 +238,8 @@
                                                 NULL, error.AsOutParam());
   if (result && !error)
   {
-    self->CreateLensFromKeyFileData(file, contents.Value(), length);
+    self->GetLensDataFromKeyFile(file, contents.Value(), length);
+    self->SortLensList();
   }
   else
   {
@@ -272,41 +248,18 @@
                      << error;
   }
   
-  self->DecrementAndCheckChildrenWaiting();
   self->cancel_map_.erase(file);
-}
 
-void FilesystemLenses::Impl::DecrementAndCheckChildrenWaiting()
-{
   // If we're not waiting for any more children to load, signal that we're
   // done reading the directory
-  children_waiting_to_load_--;
-  if (!children_waiting_to_load_)
+  self->children_waiting_to_load_--;
+  if (self->children_waiting_to_load_ == 0)
   {
-    //FIXME: This should be it's own function, but we're trying not to break ABI
-    // right now.
-    //FIXME: We don't have a strict order, but alphabetical serves us wonderfully for
-    // Oneiric. When we have an order/policy, please replace this.
-    auto sort_cb = [] (Lens::Ptr a, Lens::Ptr b) -> bool
-      {
-        if (a->id == "applications.lens")
-          return true;
-        else if (b->id == "applications.lens")
-          return false;
-        else
-          return g_strcmp0(a->id().c_str(), b->id().c_str()) < 0; 
-      };
-    std::sort(lenses_.begin(),
-              lenses_.end(),
-              sort_cb);
-    for (Lens::Ptr& lens: lenses_)
-      owner_->lens_added.emit(lens);
-
-    owner_->lenses_loaded.emit();
+    self->owner_->load_finished.emit();
   }
 }
 
-void FilesystemLenses::Impl::CreateLensFromKeyFileData(GFile* file,
+void LensDirectoryReader::Impl::GetLensDataFromKeyFile(GFile* file,
                                                        const char* data,
                                                        gsize length)
 {
@@ -318,19 +271,9 @@
   {
     if (LensFileData::IsValid(key_file, error))
     {
-      LensFileData data(key_file);
       glib::String id(g_path_get_basename(path.Value()));
 
-      Lens::Ptr lens(new Lens(id.Str(),
-                              data.dbus_name.Str(),
-                              data.dbus_path.Str(),
-                              data.name.Str(),
-                              data.icon.Str(),
-                              data.description.Str(),
-                              data.search_hint.Str(),
-                              data.visible,
-                              data.shortcut.Str()));
-      lenses_.push_back(lens);
+      lenses_data_.push_back(new LensFileData(key_file, id));
 
       LOG_DEBUG(logger) << "Sucessfully loaded lens file " << path;
     }
@@ -350,6 +293,122 @@
   g_key_file_free(key_file);
 }
 
+LensDirectoryReader::DataList LensDirectoryReader::Impl::GetLensData() const
+{
+  return lenses_data_;
+}
+
+void LensDirectoryReader::Impl::SortLensList()
+{
+  //FIXME: We don't have a strict order, but alphabetical serves us well.
+  // When we have an order/policy, please replace this.
+  auto sort_cb = [] (LensFileData* a, LensFileData* b) -> bool
+  {
+    if (a->id.Str() == "applications.lens")
+      return true;
+    else if (b->id.Str() == "applications.lens")
+      return false;
+    else
+      return g_strcmp0(a->id.Value(), b->id.Value()) < 0;
+  };
+  std::sort(lenses_data_.begin(),
+            lenses_data_.end(),
+            sort_cb);
+}
+
+LensDirectoryReader::LensDirectoryReader(std::string const& directory)
+  : pimpl(new Impl(this, directory))
+{
+}
+
+LensDirectoryReader::~LensDirectoryReader()
+{
+  delete pimpl;
+}
+
+LensDirectoryReader::Ptr LensDirectoryReader::GetDefault()
+{
+  static LensDirectoryReader::Ptr main_reader(new LensDirectoryReader(LENSES_DIR));
+
+  return main_reader;
+}
+
+bool LensDirectoryReader::IsDataLoaded() const
+{
+  return pimpl->children_waiting_to_load_ == 0 && pimpl->enumeration_done_;
+}
+
+LensDirectoryReader::DataList LensDirectoryReader::GetLensData() const
+{
+  return pimpl->GetLensData();
+}
+
+class FilesystemLenses::Impl
+{
+public:
+  Impl(FilesystemLenses* owner, LensDirectoryReader::Ptr const& reader);
+  ~Impl()
+  {
+    if (timeout_id != 0) g_source_remove (timeout_id);
+  }
+
+  void OnLoadingFinished();
+
+  LensList GetLenses() const;
+  Lens::Ptr GetLens(std::string const& lens_id) const;
+  Lens::Ptr GetLensAtIndex(std::size_t index) const;
+  Lens::Ptr GetLensForShortcut(std::string const& lens_shortcut) const;
+  std::size_t count() const;
+
+  FilesystemLenses* owner_;
+  LensDirectoryReader::Ptr reader_;
+  LensList lenses_;
+  guint timeout_id;
+};
+
+FilesystemLenses::Impl::Impl(FilesystemLenses* owner, LensDirectoryReader::Ptr const& reader)
+  : owner_(owner)
+  , reader_(reader)
+  , timeout_id(0)
+{
+  reader_->load_finished.connect(sigc::mem_fun(this, &Impl::OnLoadingFinished));
+  if (reader_->IsDataLoaded())
+  {
+    // we won't get any signal, so let's just emit our signals after construction
+    timeout_id = g_idle_add_full (G_PRIORITY_DEFAULT,
+                                  [] (gpointer data) -> gboolean {
+                                    Impl *self = (Impl*) data;
+                                    self->timeout_id = 0;
+                                    self->OnLoadingFinished();
+                                    return FALSE;
+                                  },
+                                  this, NULL);
+  }
+}
+
+void FilesystemLenses::Impl::OnLoadingFinished()
+{
+  // FIXME: clear lenses_ first?
+  for (auto lens_data : reader_->GetLensData())
+  {
+    Lens::Ptr lens(new Lens(lens_data->id,
+                            lens_data->dbus_name,
+                            lens_data->dbus_path,
+                            lens_data->name,
+                            lens_data->icon,
+                            lens_data->description,
+                            lens_data->search_hint,
+                            lens_data->visible,
+                            lens_data->shortcut));
+    lenses_.push_back (lens);
+  }
+
+  for (Lens::Ptr& lens: lenses_)
+    owner_->lens_added.emit(lens);
+
+  owner_->lenses_loaded.emit();
+}
+
 Lenses::LensList FilesystemLenses::Impl::GetLenses() const
 {
   return lenses_;
@@ -401,13 +460,13 @@
 
 
 FilesystemLenses::FilesystemLenses()
-  : pimpl(new Impl(this))
+  : pimpl(new Impl(this, LensDirectoryReader::GetDefault()))
 {
   Init();
 }
 
-FilesystemLenses::FilesystemLenses(std::string const& lens_directory)
-  : pimpl(new Impl(this, lens_directory))
+FilesystemLenses::FilesystemLenses(LensDirectoryReader::Ptr const& reader)
+  : pimpl(new Impl(this, reader))
 {
   Init();
 }

=== modified file 'UnityCore/FilesystemLenses.h'
--- UnityCore/FilesystemLenses.h	2012-02-21 21:36:27 +0000
+++ UnityCore/FilesystemLenses.h	2012-02-22 08:58:25 +0000
@@ -1,6 +1,6 @@
 // -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
 /*
- * Copyright (C) 2011 Canonical Ltd
+ * Copyright (C) 2011-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
@@ -31,6 +31,44 @@
 namespace dash
 {
 
+class LensDirectoryReader : public sigc::trackable
+{
+public:
+  struct LensFileData
+  {
+    LensFileData(GKeyFile* file, const gchar *lens_id);
+    static bool IsValid(GKeyFile* file, glib::Error& error);
+
+    glib::String id;
+    glib::String domain;
+    glib::String dbus_name;
+    glib::String dbus_path;
+    glib::String name;
+    glib::String icon;
+    glib::String description;
+    glib::String search_hint;
+    bool         visible;
+    glib::String shortcut;
+  };
+
+  typedef std::shared_ptr<LensDirectoryReader> Ptr;
+  typedef std::vector<LensFileData*> DataList;
+
+  LensDirectoryReader(std::string const& directory);
+  ~LensDirectoryReader();
+
+  static LensDirectoryReader::Ptr GetDefault();
+
+  bool IsDataLoaded() const;
+  DataList GetLensData() const;
+
+  sigc::signal<void> load_finished;
+
+private:
+  class Impl;
+  Impl* pimpl;
+};
+
 // Reads Lens information from the filesystem, as per-specification, and creates
 // Lens instances using this data
 class FilesystemLenses : public Lenses
@@ -39,9 +77,7 @@
   typedef std::shared_ptr<FilesystemLenses> Ptr;
 
   FilesystemLenses();
-  FilesystemLenses(std::string const& lens_directory);
-
-  void Init();
+  FilesystemLenses(LensDirectoryReader::Ptr const& reader);
 
   ~FilesystemLenses();
 
@@ -53,6 +89,8 @@
   sigc::signal<void> lenses_loaded;
 
 private:
+  void Init();
+
   class Impl;
   Impl* pimpl;
 };

=== modified file 'plugins/unityshell/src/BFBLauncherIcon.cpp'
--- plugins/unityshell/src/BFBLauncherIcon.cpp	2012-02-21 21:36:27 +0000
+++ plugins/unityshell/src/BFBLauncherIcon.cpp	2012-02-22 08:58:25 +0000
@@ -34,6 +34,7 @@
 
 BFBLauncherIcon::BFBLauncherIcon()
  : SimpleLauncherIcon()
+ , reader_(dash::LensDirectoryReader::GetDefault())
 {
   tooltip_text = _("Dash home");
   icon_name = PKGDATADIR"/launcher_bfb.png";
@@ -94,21 +95,21 @@
   result.push_back(menu_item);
 
   // Other lenses..
-  for (auto lens : lenses_.GetLenses())
+  for (auto lens : reader_->GetLensData())
   {
-    if (!lens->visible())
+    if (!lens->visible)
       continue;
 
     menu_item = dbusmenu_menuitem_new();
 
-    dbusmenu_menuitem_property_set(menu_item, DBUSMENU_MENUITEM_PROP_LABEL, lens->name().c_str());
+    dbusmenu_menuitem_property_set(menu_item, DBUSMENU_MENUITEM_PROP_LABEL, lens->name);
     dbusmenu_menuitem_property_set_bool(menu_item, DBUSMENU_MENUITEM_PROP_ENABLED, true);
     dbusmenu_menuitem_property_set_bool(menu_item, DBUSMENU_MENUITEM_PROP_VISIBLE, true);
 
     g_signal_connect(menu_item,
                      DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED,
                      (GCallback)&BFBLauncherIcon::OnMenuitemActivated,
-                     g_strdup(lens->id().c_str()));
+                     g_strdup(lens->id));
 
     result.push_back(menu_item);
   }

=== modified file 'plugins/unityshell/src/BFBLauncherIcon.h'
--- plugins/unityshell/src/BFBLauncherIcon.h	2012-02-21 21:36:27 +0000
+++ plugins/unityshell/src/BFBLauncherIcon.h	2012-02-22 08:58:25 +0000
@@ -51,7 +51,7 @@
 
   static unity::UBusManager ubus_manager_;
   nux::Color background_color_;
-  dash::FilesystemLenses lenses_;
+  dash::LensDirectoryReader::Ptr reader_;
 };
 
 }

=== modified file 'tests/data/lenses/files/files.lens'
--- tests/data/lenses/files/files.lens	2012-02-21 21:36:27 +0000
+++ tests/data/lenses/files/files.lens	2012-02-22 08:58:25 +0000
@@ -5,5 +5,5 @@
 Icon=/usr/share/unity-lens-files/files.png
 Description=Search for Files & Folders
 SearchHint=Search Files & Folders
-Visible=true
+Visible=false
 Shortcut=f

=== modified file 'tests/test_filesystem_lenses.cpp'
--- tests/test_filesystem_lenses.cpp	2012-02-21 21:36:27 +0000
+++ tests/test_filesystem_lenses.cpp	2012-02-22 08:58:25 +0000
@@ -45,18 +45,21 @@
 TEST(TestFilesystemLenses, TestConstruction)
 {
   FilesystemLenses lenses0;
-  FilesystemLenses lenses1(TESTDATADIR"/lenses");
+  LensDirectoryReader::Ptr test_reader(new LensDirectoryReader(TESTDATADIR"/lenses"));
+  FilesystemLenses lenses1(test_reader);
 }
 
 TEST(TestFilesystemLenses, TestFileLoading)
 {
-  FilesystemLenses lenses(TESTDATADIR"/lenses");
+  LensDirectoryReader::Ptr test_reader(new LensDirectoryReader(TESTDATADIR"/lenses"));
+  FilesystemLenses lenses(test_reader);
   WaitForLensesToLoad(lenses);
 }
 
 TEST(TestFilesystemLenses, TestLensesAdded)
 {
-  FilesystemLenses lenses(TESTDATADIR"/lenses");
+  LensDirectoryReader::Ptr test_reader(new LensDirectoryReader(TESTDATADIR"/lenses"));
+  FilesystemLenses lenses(test_reader);
   unsigned int n_lenses = 0;
 
   auto lens_added_cb = [&n_lenses](Lens::Ptr & p)
@@ -72,7 +75,8 @@
 
 TEST(TestFilesystemLenses, TestLensContent)
 {
-  FilesystemLenses lenses(TESTDATADIR"/lenses");
+  LensDirectoryReader::Ptr test_reader(new LensDirectoryReader(TESTDATADIR"/lenses"));
+  FilesystemLenses lenses(test_reader);
   WaitForLensesToLoad(lenses);
 
   // Test that the lenses have loaded correctly
@@ -95,7 +99,7 @@
   EXPECT_EQ(lens->icon_hint, "/usr/share/unity-lens-files/files.png");
   EXPECT_EQ(lens->description, "Search for Files & Folders");
   EXPECT_EQ(lens->search_hint, "Search Files & Folders");
-  EXPECT_EQ(lens->visible, true);
+  EXPECT_EQ(lens->visible, false);
   EXPECT_EQ(lens->shortcut, "f");
 
   lens = lenses.GetLens("social.lens");
@@ -106,7 +110,7 @@
   EXPECT_EQ(lens->icon_hint, "/usr/share/unity-lens-social/social.png");
   EXPECT_EQ(lens->description, "");
   EXPECT_EQ(lens->search_hint, "");
-  EXPECT_EQ(lens->visible, false);
+  EXPECT_EQ(lens->visible, true);
   EXPECT_EQ(lens->shortcut, "");
 }