Merge lp:~charlesk/indicator-transfer/better-content-hub-use into lp:indicator-transfer/14.10

[Charles Kerr]

Better use of information provided by content-hub.

=== Description of the Change

Better use of information provided by content-hub + only show downloads that work with content-hub.

1. Don't show transfers that don't go through content-hub. In particular, wait until a DownloadIdChanged signal is received from content-hub so that the content-hub and ubuntu-download-manager objects can be collated. (bug #1350771) (bug #1350307)

2. Use the transfer's peer's click manifest's icon for the menuitem's icon. (bug #1361347)

3. When we have a destination uri available, use its basename() as the menuitem's title. This currently is available only after the download is completed; getting it earlier will come in another patch when the information is available from content-hub or download-manager.

4. If the clears a transfer off of the indicator, don't bring it back even if more signals are received for the corresponding object from content-hub or download-manager. (bug #1348170)

5. implement Transfer::open() (using content-hub's Charge() method) and Transfer::open_app() using ubunbu-app-launch for the transfer's peer. (bug #1361363)

6. If a download object on the bus says that the amount downloaded exceeds the total size, stop estimating the ETA since we don't know how much is left to be downloaded. (bug #1348162)

=== Merge Proposal Checklist

> Are there any related MPs required for this MP to build/function as expected? Please list.

Not directly. However, be aware when you test that there's an outstanding unity8 regression (tracked in bug #1350308) that prevents rendering from being acceptable, both with and without this MP.

> Is your branch in sync with latest trunk? (e.g. bzr pull lp:trunk -> no changes)

Yes

> Did the code build without warnings?

Yes

> Did the tests run successfully?

Yes

> Did you perform an exploratory manual test run of your code change and any related functionality?

Yes, utopic image 210 on a mako device

> Has your component test plan been executed successfully on emulator or a physical device?

Yes

> Please list which manual tests are germane for the reviewer in this MP.

indicator-transfer/simple-download-check

When testing, please note the comment above about rendering.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:18
http://jenkins.qa.ubuntu.com/job/indicator-transfer-ci/7/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-transfer-utopic-amd64-ci/7
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-transfer-utopic-armhf-ci/7
        deb: http://jenkins.qa.ubuntu.com/job/indicator-transfer-utopic-armhf-ci/7/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/indicator-transfer-ci/7/rebuild

review: Approve (continuous-integration)

[Ted Gould (ted)]

Few comments.

review: Needs Fixing

[lp:~charlesk/indicator-transfer/better-content-hub-use]

19. By Charles Kerr on 2014-08-26

simplify the download speed estimation.

20. By Charles Kerr on 2014-08-26

fix the error-checking when trying to get an icon from click's manifest

[Ted Gould (ted)]

Great!

review: Approve

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:20
http://jenkins.qa.ubuntu.com/job/indicator-transfer-ci/8/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-transfer-utopic-amd64-ci/8
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-transfer-utopic-armhf-ci/8
        deb: http://jenkins.qa.ubuntu.com/job/indicator-transfer-utopic-armhf-ci/8/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/indicator-transfer-ci/8/rebuild

review: Approve (continuous-integration)

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2014-06-17 01:36:16 +0000
+++ CMakeLists.txt	2014-08-26 20:52:17 +0000
@@ -31,11 +31,14 @@
 find_package (PkgConfig REQUIRED)
 include (FindPkgConfig)
 
-pkg_check_modules (SERVICE_DEPS REQUIRED
-                   glib-2.0>=2.36
-                   gio-unix-2.0>=2.36
-                   properties-cpp>=0.0.1)
-include_directories (SYSTEM ${SERVICE_DEPS_INCLUDE_DIRS})
+pkg_check_modules(SERVICE_DEPS REQUIRED
+                  glib-2.0>=2.36
+                  gio-unix-2.0>=2.36
+                  properties-cpp>=0.0.1
+                  click-0.4>=0.4.30
+                  json-glib-1.0
+                  ubuntu-app-launch-2)
+include_directories(SYSTEM ${SERVICE_DEPS_INCLUDE_DIRS})
 
 ##
 ##  custom targets

=== modified file 'debian/control'
--- debian/control	2014-06-25 15:34:10 +0000
+++ debian/control	2014-08-26 20:52:17 +0000
@@ -8,6 +8,9 @@
                g++-4.9,
                libglib2.0-dev (>= 2.35.4),
                libproperties-cpp-dev,
+               libclick-0.4-dev (>= 0.4.30),
+               libjson-glib-dev,
+               libubuntu-app-launch2-dev,
 # for coverage reports
                lcov,
 # for tests

=== modified file 'include/transfer/transfer.h'
--- include/transfer/transfer.h	2014-06-25 22:48:12 +0000
+++ include/transfer/transfer.h	2014-08-26 20:52:17 +0000
@@ -56,7 +56,8 @@
   // [0...1]
   float progress = 0.0;
 
-  uint64_t speed_bps = 0;
+  // bytes per second
+  uint64_t speed_Bps = 0;
 
   uint64_t total_size = 0;
 

=== modified file 'include/transfer/world-dbus.h'
--- include/transfer/world-dbus.h	2014-06-17 01:36:16 +0000
+++ include/transfer/world-dbus.h	2014-08-26 20:52:17 +0000
@@ -47,19 +47,8 @@
     void open_app(const Transfer::Id& id);
 
 private:
-    GDBusConnection* m_bus = nullptr;
-    GCancellable* m_cancellable = nullptr;
-    std::set<guint> m_signal_subscriptions;
-    std::shared_ptr<MutableModel> m_model;
-
-    void set_bus(GDBusConnection*);
-    void add_transfer(const char* object_path);
-
-    static void on_bus_ready(GObject*, GAsyncResult*, gpointer);
-    static void on_progress(GObject*, GAsyncResult*, gpointer);
-    static void on_total_size(GObject*, GAsyncResult*, gpointer);
-    static void on_download_signal(GDBusConnection*, const gchar*, const gchar*, const gchar*, const gchar*, GVariant*, gpointer);
-    static void on_download_created(GDBusConnection*, const gchar*, const gchar*, const gchar*, const gchar*, GVariant*, gpointer);
+    class Impl;
+    std::unique_ptr<Impl> impl;
 };
 
 } // namespace transfer

=== modified file 'src/view-console.cpp'
--- src/view-console.cpp	2014-06-17 01:36:16 +0000
+++ src/view-console.cpp	2014-08-26 20:52:17 +0000
@@ -56,7 +56,7 @@
                               transfer->app_icon.c_str(),
                               (size_t)transfer->time_started,
                               transfer->seconds_left,
-                              transfer->speed_bps/1024.0,
+                              transfer->speed_Bps/1024.0,
                               transfer->progress,
                               transfer->error_string.c_str(),
                               transfer->local_path.c_str());

=== modified file 'src/view-gmenu.cpp'
--- src/view-gmenu.cpp	2014-07-09 21:18:50 +0000
+++ src/view-gmenu.cpp	2014-08-26 20:52:17 +0000
@@ -152,8 +152,9 @@
     if (transfer)
       {
         g_variant_builder_add(&b, "{sv}", "percent",
-                              g_variant_new_double(transfer->progress));
-        if (transfer->seconds_left >= 0)
+                              g_variant_new_double(CLAMP(transfer->progress, 0.0, 1.0)));
+
+        if ((transfer->seconds_left >= 0) && (int(transfer->progress*100.0) < 100))
           {
             g_variant_builder_add(&b, "{sv}", "seconds-left",
                                   g_variant_new_int32(transfer->seconds_left));
@@ -612,11 +613,23 @@
     g_menu_item_set_attribute (menu_item, ATTRIBUTE_X_TYPE,
                                "s", "com.canonical.indicator.transfer");
 
-    //FIXME: this is a placeholder
-    auto icon = g_themed_icon_new("image-missing");
-    auto v = g_icon_serialize(icon);
-    g_menu_item_set_attribute_value (menu_item, G_MENU_ATTRIBUTE_ICON, v);
-    g_object_unref(icon);
+    GVariant * serialized_icon = nullptr;
+    if (!t->app_icon.empty() && g_file_test(t->app_icon.c_str(), G_FILE_TEST_EXISTS))
+      {
+        auto file = g_file_new_for_path(t->app_icon.c_str());
+        auto icon = g_file_icon_new(file);
+        serialized_icon = g_icon_serialize(icon);
+        g_clear_object(&icon);
+        g_clear_object(&file);
+      }
+    if (serialized_icon == nullptr)
+      {
+        auto icon = g_themed_icon_new("image-missing");
+        serialized_icon = g_icon_serialize(icon);
+        g_clear_object(&icon);
+      }
+    g_menu_item_set_attribute_value (menu_item, G_MENU_ATTRIBUTE_ICON, serialized_icon);
+    g_variant_unref(serialized_icon);
 
     g_menu_item_set_attribute (menu_item, ATTRIBUTE_X_UID, "s", id);
     g_menu_item_set_action_and_target_value (menu_item,

=== modified file 'src/world-dbus.cpp'
--- src/world-dbus.cpp	2014-07-09 22:33:01 +0000
+++ src/world-dbus.cpp	2014-08-26 20:52:17 +0000
@@ -19,6 +19,12 @@
 
 #include <transfer/world-dbus.h>
 
+#include <click.h>
+#include <ubuntu-app-launch.h>
+
+#include <json-glib/json-glib.h>
+
+#include <algorithm>
 #include <iostream>
 
 namespace unity {
@@ -27,25 +33,41 @@
 
 namespace {
 
-#define BUS_NAME "com.canonical.applications.Downloader"
-#define DOWNLOAD_MANAGER_IFACE_NAME "com.canonical.applications.DownloadManager"
-#define DOWNLOAD_IFACE_NAME "com.canonical.applications.Download"
-
+static constexpr char const * DM_BUS_NAME {"com.canonical.applications.Downloader"};
+static constexpr char const * DM_MANAGER_IFACE_NAME {"com.canonical.applications.DownloadManager"};
+static constexpr char const * DM_DOWNLOAD_IFACE_NAME {"com.canonical.applications.Download"};
+
+static constexpr char const * CH_BUS_NAME {"com.ubuntu.content.dbus.Service"};
+static constexpr char const * CH_TRANSFER_IFACE_NAME {"com.ubuntu.content.dbus.Transfer"};
+
+
+/**
+ * A Transfer whose state comes from content-hub and ubuntu-download-manager.
+ * 
+ * Each DBusTransfer tracks a com.canonical.applications.Download (ccad) object
+ * from ubuntu-download-manager. The ccad is used for pause/resume/cancel,
+ * state change / download progress signals, etc.
+ *
+ * Each DBusTransfer also tracks a com.ubuntu.content.dbus.Transfer (cucdt)
+ * object from content-hub. The cucdt is used for learning the download's peer
+ * and for calling Charge() to launch the peer's app.
+ */
 class DBusTransfer: public Transfer
 {
 public:
 
-  DBusTransfer(GDBusConnection* connection, const char* object_path):
+  DBusTransfer(GDBusConnection* connection,
+               const std::string& ccad_path,
+               const std::string& cucdt_path):
     m_bus(G_DBUS_CONNECTION(g_object_ref(connection))),
     m_cancellable(g_cancellable_new()),
-    m_object_path(object_path)
+    m_ccad_path(ccad_path),
+    m_cucdt_path(cucdt_path)
   {
-    g_debug("creating a new DBusTransfer for '%s'", object_path);
-
     id = next_unique_id();
     time_started = time(nullptr);
-
-    get_properties_from_bus();
+    get_ccad_properties();
+    get_cucdt_properties();
   }
 
   ~DBusTransfer()
@@ -59,39 +81,82 @@
 
   void start()
   {
-    g_return_if_fail (can_start());
+    g_return_if_fail(can_start());
     
-    call_method_no_args_no_response ("start");
+    call_ccad_method_no_args_no_response("start");
   }
 
   void pause()
   {
-    g_return_if_fail (can_pause());
+    g_return_if_fail(can_pause());
     
-    call_method_no_args_no_response("pause");
+    call_ccad_method_no_args_no_response("pause");
   }
 
   void resume()
   {
     g_return_if_fail(can_resume());
 
-    call_method_no_args_no_response("resume");
+    call_ccad_method_no_args_no_response("resume");
   }
 
   void cancel()
   {
-    call_method_no_args_no_response("cancel");
-  }
-
-  const std::string& object_path() const
-  {
-    return m_object_path;
-  }
-
-  void handle_signal(const gchar* signal_name, GVariant* parameters)
-  {
-    g_debug ("%s transfer %s got signal '%s'", G_STRLOC, id.c_str(), signal_name);
-
+    call_ccad_method_no_args_no_response("cancel");
+  }
+
+  void open()
+  {
+    /* Once a transfer is complete, an app can be launched to process
+       it by calling Charge() with an empty variant list argument */
+    g_return_if_fail(!m_cucdt_path.empty());
+    g_dbus_connection_call(m_bus,
+                           CH_BUS_NAME,
+                           m_cucdt_path.c_str(),
+                           CH_TRANSFER_IFACE_NAME,
+                           "Charge",
+                           g_variant_new("(av)", nullptr),
+                           nullptr,
+                           G_DBUS_CALL_FLAGS_NONE,
+                           -1, // default timeout
+                           m_cancellable,
+                           on_cucdt_charge, // callback
+                           nullptr); // callback user_data
+  }
+
+  void open_app()
+  {
+    g_return_if_fail(!m_peer_name.empty());
+
+    gchar* app_id = ubuntu_app_launch_triplet_to_app_id(m_peer_name.c_str(), nullptr, nullptr);
+    g_debug("calling ubuntu_app_launch_start_application() for %s", app_id);
+    ubuntu_app_launch_start_application(app_id, nullptr);
+    g_free(app_id);
+  }
+
+  const std::string& cucdt_path() const
+  {
+    return m_cucdt_path;
+  }
+
+  const std::string& ccad_path() const
+  {
+    return m_ccad_path;
+  }
+
+  void handle_cucdt_signal(const gchar* signal_name, GVariant* parameters)
+  {
+    if (!g_strcmp0(signal_name, "StoreChanged"))
+      {
+        const gchar* uri = nullptr;
+        g_variant_get_child(parameters, 0, "&s", &uri);
+        if (uri != nullptr)
+          set_store(uri);
+      }
+  }
+
+  void handle_ccad_signal(const gchar* signal_name, GVariant* parameters)
+  {
     if (!g_strcmp0(signal_name, "started"))
       {
         if (get_signal_success_arg(parameters))
@@ -151,7 +216,7 @@
         int32_t i;
         char* str = nullptr;
         g_variant_get_child(parameters, 0, "(is)", &i, &str);
-        g_message("%s setting error to '%s'", G_STRLOC, str);
+        g_debug("%s setting error to '%s'", G_STRLOC, str);
         set_error_string(str);
         set_state(ERROR);
         g_free(str);
@@ -166,9 +231,19 @@
 
 private:
 
-  // the 'started', 'paused', 'resumed', and 'canceled' signals
-  // from com.canonical.applications.Download all have a single
-  // parameter, a boolean success flag.
+  static void on_cucdt_charge(GObject      * source,
+                              GAsyncResult * res,
+                              gpointer       /*unused*/)
+  {
+    auto v = connection_call_finish(source, res, "Error calling Charge()");
+    g_clear_pointer(&v, g_variant_unref);
+  }
+
+  void emit_changed() { changed()(); }
+
+  /* The 'started', 'paused', 'resumed', and 'canceled' signals
+     from com.canonical.applications.Download all have a single
+     parameter, a boolean success flag. */
   bool get_signal_success_arg(GVariant* parameters)
   {
     gboolean success = false;
@@ -178,70 +253,32 @@
     return success;
   }
 
-  void call_method_no_args_no_response(const char* method_name)
-  {
-    g_debug ("%s transfer %s calling '%s'", G_STRLOC, id.c_str(), method_name);
-
-    g_dbus_connection_call(m_bus,                  // connection
-                           BUS_NAME,               // bus_name
-                           m_object_path.c_str(),  // object path
-                           DOWNLOAD_IFACE_NAME,    // interface name
-                           method_name,            // method name
-                           nullptr,                // parameters
-                           nullptr,                // reply type
-                           G_DBUS_CALL_FLAGS_NONE, // flags
-                           -1,                     // default timeout
-                           m_cancellable,          // cancellable
-                           nullptr,                // callback
-                           nullptr                 /*user data*/);
-  }
-
-
-  core::Signal<> m_changed;
-  void emit_changed() { changed()(); }
-
-  uint64_t m_received = 0;
-  uint64_t m_total_size = 0;
-  std::vector<std::pair<GTimeVal,uint64_t>> m_history;
-
-  static double get_time_from_timeval(const GTimeVal& t)
-  {
-    return t.tv_sec + (t.tv_usec / (double)G_USEC_PER_SEC);
-  }
-
-  // gets an averaged speed based on information saved from 
-  // recent calls to set_progress()
-  uint64_t get_average_speed_bps()
-  {
-    unsigned int n_samples = 0;
-    uint64_t sum = 0;
-
-    // prune out samples by size
+  uint64_t get_averaged_speed_Bps()
+  {
+    // limit the average to the last X samples
     static constexpr int max_slots = 50;
     if (m_history.size() > max_slots)
       m_history.erase(m_history.begin(), m_history.end()-max_slots);
 
-    static constexpr time_t max_age_seconds = 30;
-    GTimeVal now_tv;
-    g_get_current_time(&now_tv);
-    const double now = get_time_from_timeval(now_tv);
-    for(unsigned i=1; i<m_history.size(); i++)
-      {
-        const double begin_time = get_time_from_timeval(m_history[i-1].first);
-        if (now - begin_time > max_age_seconds)
-          continue;
-
-        const double end_time = get_time_from_timeval(m_history[i].first);
-        const double time_diff = end_time - begin_time;
-        const uint64_t received_diff = m_history[i].second -
-                                       m_history[i-1].second;
-        const uint64_t bps = uint64_t(received_diff / time_diff);
-
-        sum += bps;
-        ++n_samples;
-      }
-
-    return n_samples ? sum / n_samples : 0;
+    // limit the average to the last Y seconds
+    static constexpr unsigned int max_age_seconds = 30;
+    const auto oldest_allowed_usec = g_get_real_time() - (max_age_seconds * G_USEC_PER_SEC);
+    const auto is_young = [oldest_allowed_usec](const DownloadProgress& p){return p.time_usec >= oldest_allowed_usec;};
+    m_history.erase(std::begin(m_history), std::find_if(std::begin(m_history), std::end(m_history), is_young));
+
+    uint64_t Bps;
+
+    if (m_history.size() < 2)
+      {
+        Bps = 0;
+      }
+    else
+      {
+        const auto diff = m_history.back() - m_history.front();
+        Bps = (diff.bytes * G_USEC_PER_SEC) / diff.time_usec;
+      }
+
+    return Bps;
   }
 
   void update_progress()
@@ -249,27 +286,25 @@
     auto tmp_total_size = total_size;
     auto tmp_progress = progress;
     auto tmp_seconds_left = seconds_left;
-    auto tmp_speed_bps = speed_bps;
+    auto tmp_speed_Bps = speed_Bps;
 
     if (m_total_size && m_received)
       {
         // update our speed tables
-        GTimeVal now;
-        g_get_current_time(&now);
-        m_history.push_back(std::pair<GTimeVal,uint64_t>(now, m_received));
+        m_history.push_back(DownloadProgress{g_get_real_time(),m_received});
 
-        const auto bps = get_average_speed_bps();
-        const int seconds = bps ? (int)((m_total_size - m_received) / bps) : -1;
+        const auto Bps = get_averaged_speed_Bps();
+        const int seconds = Bps ? (int)((m_total_size - m_received) / Bps) : -1;
 
         tmp_total_size = m_total_size;
-        tmp_speed_bps = bps;
+        tmp_speed_Bps = Bps;
         tmp_progress = m_received / (float)m_total_size;
         tmp_seconds_left = seconds;
       }
     else
       {
         tmp_total_size = 0;
-        tmp_speed_bps = 0;
+        tmp_speed_Bps = 0;
         tmp_progress = 0.0;
         tmp_seconds_left = -1;
       }
@@ -284,13 +319,14 @@
 
     if (seconds_left != tmp_seconds_left)
       {
+        g_debug("changing '%s' seconds_left to '%d'", m_ccad_path.c_str(), (int)tmp_seconds_left);
         seconds_left = tmp_seconds_left;
         changed = true;
       }
 
-    if (speed_bps != tmp_speed_bps)
+    if (speed_Bps != tmp_speed_Bps)
       {
-        speed_bps = tmp_speed_bps;
+        speed_Bps = tmp_speed_Bps;
         changed = true;
       }
 
@@ -312,7 +348,7 @@
 
         if (!can_pause())
           {
-            speed_bps = 0;
+            speed_Bps = 0;
             m_history.clear();
           }
  
@@ -325,6 +361,7 @@
     const std::string tmp = str ? str : "";
     if (error_string != tmp)
     {
+      g_debug("changing '%s' error to '%s'", m_ccad_path.c_str(), tmp.c_str());
       error_string = tmp;
       emit_changed();
     }
@@ -334,60 +371,155 @@
   {
     const std::string tmp = str ? str : "";
     if (local_path != tmp)
-    {
-      local_path = tmp;
-      emit_changed();
-    }
-  }
-
-  /***
-  ****  DBUS
-  ***/
-
-  GDBusConnection* m_bus = nullptr;
-  GCancellable* m_cancellable = nullptr;
-  const std::string m_object_path;
-
-  void get_properties_from_bus()
-  {
-    const auto bus_name = BUS_NAME;
-    const auto object_path = m_object_path.c_str();
-    const auto interface_name = DOWNLOAD_IFACE_NAME;
+      {
+        g_debug("changing '%s' path to '%s'", m_ccad_path.c_str(), tmp.c_str());
+        local_path = tmp;
+        emit_changed();
+      }
+
+    // If we don't already have a title,
+    // use the file's basename as the title
+    if (title.empty())
+      {
+        auto bname = g_path_get_basename(str);
+        set_title(bname);
+        g_free(bname);
+      }
+  }
+
+  void set_title(const char* title_in)
+  {
+    const std::string tmp = title_in ? title_in : "";
+    if (title != tmp)
+      {
+        g_debug("changing '%s' title to '%s'", m_ccad_path.c_str(), tmp.c_str());
+        title = tmp;
+        emit_changed();
+      }
+  }
+
+  void set_store(const char* store)
+  {
+    /**
+     * This is a workaround until content-hub exposes a peer getter.
+     * As an interim step, this code sniffs the peer by looking at the store.
+     * the peer's listed in the directory component before HubIncoming, e.g.:
+     * "/home/phablet/.cache/com.ubuntu.gallery/HubIncoming/4"
+     */
+    char** strv = g_strsplit(store, "/", -1);
+    int i=0;
+    for ( ; strv && strv[i]; ++i)
+      if (!g_strcmp0(strv[i], "HubIncoming") && (i>0))
+        set_peer_name(strv[i-1]);
+    g_strfreev(strv);
+  }
+
+  void set_peer_name(const char* peer_name)
+  {
+    g_return_if_fail(peer_name && *peer_name);
+
+    g_debug("changing '%s' peer_name to '%s'", m_ccad_path.c_str(), peer_name);
+    m_peer_name = peer_name;
+
+    /* If we can find a click icon for the peer,
+       Use it as the transfer's icon */
+
+    GError* error = nullptr;
+    auto user = click_user_new_for_user(nullptr, nullptr, &error);
+    if (user != nullptr)
+      {
+        gchar* path = click_user_get_path(user, peer_name, &error);
+        if (path != nullptr)
+          {
+            auto manifest = click_user_get_manifest(user, peer_name, &error);
+            if (manifest != nullptr)
+              {
+                const auto icon_name = json_object_get_string_member(manifest, "icon");
+                if (icon_name != nullptr)
+                  {
+                    auto filename = g_build_filename(path, icon_name, nullptr);
+                    set_icon(filename);
+                    g_free(filename);
+                  }
+              }
+            g_free(path);
+          }
+      }
+
+    if (error != nullptr)
+      g_warning("Unable to get manifest for '%s' package: %s", peer_name, error->message);
+
+    g_clear_object(&user);
+    g_clear_error(&error);
+  }
+
+  void set_icon(const char* filename)
+  {
+    const std::string tmp = filename ? filename : "";
+    if (app_icon != tmp)
+      {
+        g_debug("changing '%s' icon to '%s'", m_ccad_path.c_str(), tmp.c_str());
+        app_icon = tmp;
+        emit_changed();
+      }
+  }
+
+  /***
+  ****  Content Hub
+  ***/
+
+  void get_cucdt_properties()
+  {
+    const auto bus_name = CH_BUS_NAME;
+    const auto object_path = m_cucdt_path.c_str();
+    const auto interface_name = CH_TRANSFER_IFACE_NAME;
+
+    g_dbus_connection_call(m_bus, bus_name, object_path, interface_name,
+                           "Store", nullptr, G_VARIANT_TYPE("(s)"),
+                           G_DBUS_CALL_FLAGS_NONE, -1,
+                           m_cancellable, on_cucdt_store, this);
+  }
+
+  static void on_cucdt_store(GObject* source, GAsyncResult* res, gpointer gself)
+  {
+    auto v = connection_call_finish(source, res, "Unable to get store");
+    if (v != nullptr)
+      {
+        const gchar* store = nullptr;
+        g_variant_get_child(v, 0, "&s", &store);
+        if (store != nullptr)
+          static_cast<DBusTransfer*>(gself)->set_store(store);
+        g_variant_unref(v);
+      }
+  }
+
+  /***
+  ****  DownloadManager
+  ***/
+
+  void get_ccad_properties()
+  {
+    const auto bus_name = DM_BUS_NAME;
+    const auto object_path = m_ccad_path.c_str();
+    const auto interface_name = DM_DOWNLOAD_IFACE_NAME;
 
     g_dbus_connection_call(m_bus, bus_name, object_path, interface_name,
                            "totalSize", nullptr, G_VARIANT_TYPE("(t)"),
                            G_DBUS_CALL_FLAGS_NONE, -1,
-                           m_cancellable, on_total_size, this);
+                           m_cancellable, on_ccad_total_size, this);
 
     g_dbus_connection_call(m_bus, bus_name, object_path, interface_name,
                            "progress", nullptr, G_VARIANT_TYPE("(t)"),
                            G_DBUS_CALL_FLAGS_NONE, -1,
-                           m_cancellable, on_progress, this);
-
-    g_dbus_connection_call(m_bus, bus_name, object_path, interface_name,
-                           "metadata", nullptr, G_VARIANT_TYPE("(a{sv})"),
-                           G_DBUS_CALL_FLAGS_NONE, -1,
-                           m_cancellable, on_metadata, this);
+                           m_cancellable, on_ccad_progress, this);
   }
 
-  static void on_total_size(GObject* connection,
-                            GAsyncResult* res,
-                            gpointer gself)
+  static void on_ccad_total_size(GObject      * source,
+                                 GAsyncResult * res,
+                                 gpointer       gself)
   {
-    GError* error = nullptr;
-
-    auto v = g_dbus_connection_call_finish(G_DBUS_CONNECTION(connection),
-                                           res,
-                                           &error);
-
-    if (error != nullptr)
-      {
-        if (!g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
-          g_warning("Couldn't get download total size: %s", error->message);
-
-        g_error_free(error);
-      }
-    else
+    auto v = connection_call_finish(source, res, "Error calling totalSize()");
+    if (v != nullptr)
       {
         guint64 n = 0;
         g_variant_get_child(v, 0, "t", &n);
@@ -399,23 +531,12 @@
       }
   }
 
-  static void on_progress(GObject* connection,
-                          GAsyncResult* res,
-                          gpointer gself)
+  static void on_ccad_progress(GObject      * source,
+                               GAsyncResult * res,
+                               gpointer       gself)
   {
-    GError* error = nullptr;
-    auto v = g_dbus_connection_call_finish(G_DBUS_CONNECTION(connection),
-                                           res,
-                                           &error);
-
-    if (error != nullptr)
-      {
-        if (!g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
-          g_warning("Couldn't get download progress: %s", error->message);
-
-        g_error_free(error);
-      }
-    else
+    auto v = connection_call_finish(source, res, "Error calling progress()");
+    if (v != nullptr)
       {
         guint64 n = 0;
         g_variant_get_child(v, 0, "t", &n);
@@ -427,31 +548,63 @@
       }
   }
 
-  static void on_metadata(GObject* connection,
-                          GAsyncResult* res,
-                          gpointer)// gself)
+  void call_ccad_method_no_args_no_response(const char* method_name)
+  {
+    const auto bus_name = DM_BUS_NAME;
+    const auto object_path = m_ccad_path.c_str();
+    const auto interface_name = DM_DOWNLOAD_IFACE_NAME;
+
+    g_debug("%s transfer %s calling '%s'", G_STRLOC, id.c_str(), method_name);
+
+    g_dbus_connection_call(m_bus, bus_name, object_path, interface_name,
+                           method_name, nullptr, nullptr,
+                           G_DBUS_CALL_FLAGS_NONE, -1,
+                           m_cancellable, nullptr, nullptr);
+  }
+
+  /***
+  ****
+  ***/
+
+  static GVariant* connection_call_finish(GObject      * connection,
+                                          GAsyncResult * res,
+                                          const char   * warning)
   {
     GError* error = nullptr;
+
     auto v = g_dbus_connection_call_finish(G_DBUS_CONNECTION(connection),
                                            res,
                                            &error);
 
-    if (error != nullptr)
+    if (v == nullptr)
       {
         if (!g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
-          g_warning("Couldn't get download metadata: %s", error->message);
+          g_warning("%s: %s", warning, error->message);
 
         g_error_free(error);
       }
-    else
-      {
-        char * variant_str = g_variant_print(v, true);
-        // FIXME: pull appname (and icon) and title from metadata?
-        g_warning("%s unhandled metadata: %s", G_STRFUNC, variant_str);
-        g_free(variant_str);
-        g_variant_unref(v);
-      }
+
+    return v;
   }
+
+  core::Signal<> m_changed;
+
+  uint64_t m_received = 0;
+  uint64_t m_total_size = 0;
+  struct DownloadProgress {
+    int64_t time_usec; // microseconds since epoch
+    uint64_t bytes;
+    DownloadProgress operator-(const DownloadProgress& that) {
+      return DownloadProgress{time_usec-that.time_usec, bytes-that.bytes};
+    }
+  };
+  std::vector<DownloadProgress> m_history;
+
+  GDBusConnection* m_bus = nullptr;
+  GCancellable* m_cancellable = nullptr;
+  const std::string m_ccad_path;
+  const std::string m_cucdt_path;
+  std::string m_peer_name;
 };
 
 } // anonymous namespace
@@ -460,215 +613,305 @@
 ****
 ***/
 
-DBusWorld::DBusWorld(const std::shared_ptr<MutableModel>& model):
+class DBusWorld::Impl
+{
+public:
+
+  Impl(const std::shared_ptr<MutableModel>& model):
     m_cancellable(g_cancellable_new()),
     m_model(model)
-{
+  {
     g_bus_get(G_BUS_TYPE_SESSION, m_cancellable, on_bus_ready, this);
-}
-
-DBusWorld::~DBusWorld()
-{
+
+    m_model->removed().connect([this](const Transfer::Id& id){
+      auto transfer = find_transfer_by_id(id);
+      if (transfer)
+        m_removed_ccad.insert(transfer->ccad_path());
+    });
+  }
+
+  ~Impl()
+  {
     g_cancellable_cancel(m_cancellable);
     g_clear_object(&m_cancellable);
     set_bus(nullptr);
     g_clear_object(&m_bus);
-}
-
-void DBusWorld::on_bus_ready(GObject* /*source_object*/,
-                            GAsyncResult* res,
-                            gpointer gself)
-{
-  GError* error = nullptr;
-  auto bus = g_bus_get_finish(res, &error);
-
-  if (error != nullptr)
-    {
-      if (!g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
-        g_warning("Could not get session bus: %s", error->message);
-
-      g_error_free(error);
-    }
-  else
-    {
-      static_cast<DBusWorld*>(gself)->set_bus(bus);
-      g_object_unref(bus);
-    }
-}
-
-void DBusWorld::set_bus(GDBusConnection* bus)
-{
-  if (m_bus != nullptr)
-    {
-      for (const auto& tag : m_signal_subscriptions)
-        g_dbus_connection_signal_unsubscribe(m_bus, tag);
-
-      m_signal_subscriptions.clear();
-      g_clear_object(&m_bus);
-    }
-
-  if (bus != nullptr)
-    {
-      g_debug("%s: %s", G_STRFUNC, g_dbus_connection_get_unique_name(bus));
-      m_bus = G_DBUS_CONNECTION(g_object_ref(bus));
-
-      guint tag;
-      tag = g_dbus_connection_signal_subscribe(bus,
-                                               BUS_NAME,
-                                               DOWNLOAD_MANAGER_IFACE_NAME,
-                                               "downloadCreated",
-                                               "/",
-                                               nullptr,
-                                               G_DBUS_SIGNAL_FLAGS_NONE,
-                                               on_download_created,
-                                               this,
-                                               nullptr);
-      m_signal_subscriptions.insert(tag);
-
-      tag = g_dbus_connection_signal_subscribe (bus,
-                                                BUS_NAME,
-                                                DOWNLOAD_IFACE_NAME,
-                                                nullptr,
-                                                nullptr,
-                                                nullptr,
-                                                G_DBUS_SIGNAL_FLAGS_NONE,
-                                                on_download_signal,
-                                                this,
-                                                nullptr);
-      m_signal_subscriptions.insert(tag);
-    }
-}
-
-namespace
-{
-  std::shared_ptr<DBusTransfer>
-  find_dbus_transfer_for_object_path(const std::shared_ptr<Model>& model,
-                                     const std::string& object_path)
-  {
-    std::shared_ptr<DBusTransfer> dbus_transfer;
-
-    for (const auto& transfer : model->get_all())
-      {
-        const auto tmp = std::static_pointer_cast<DBusTransfer>(transfer);
-
-        if (tmp && (tmp->object_path()==object_path))
-          {
-             dbus_transfer = tmp;
-             break;
-          }
-      }
-
-    return dbus_transfer;
-  }
-}
-
-void DBusWorld::on_download_signal(GDBusConnection*, //connection,
-                                  const gchar*,      //sender_name,
-                                  const gchar*         object_path,
-                                  const gchar*,      //interface_name,
-                                  const gchar*         signal_name,
-                                  GVariant*            parameters,
-                                  gpointer             gself)
-{
-  auto self = static_cast<DBusWorld*>(gself);
-
-  auto dbus_transfer = find_dbus_transfer_for_object_path(self->m_model, object_path);
-
-  if (!dbus_transfer)
-    {
-      g_message("A %s that we didn't know about just emitted signal '%s' -- "
-                "might be a transfer that was here before us?",
-                DOWNLOAD_IFACE_NAME, signal_name);
-      self->add_transfer(object_path);
-      dbus_transfer = find_dbus_transfer_for_object_path(self->m_model, object_path);
-      g_return_if_fail (dbus_transfer);
-    }
-
-  dbus_transfer->handle_signal(signal_name, parameters);
-}
-
-void DBusWorld::on_download_created(GDBusConnection*, //connection,
-                                   const gchar*,      //sender_name,
-                                   const gchar*,      //object_path,
-                                   const gchar*,      //interface_name,
-                                   const gchar*,      //signal_name,
-                                   GVariant*            parameters,
-                                   gpointer             gself)
-{
-  gchar* download_path = nullptr;
-  g_variant_get_child(parameters, 0, "o", &download_path);
-
-  if (download_path != nullptr)
-    {
-      if (g_variant_is_object_path(download_path))
-        static_cast<DBusWorld*>(gself)->add_transfer(download_path);
-
-      g_free(download_path);
-    }
-}
-
-void DBusWorld::add_transfer(const char* object_path)
-{
-  // create a new Transfer and pass it to the model
-  auto dbus_transfer = new DBusTransfer(m_bus, object_path);
-  std::shared_ptr<Transfer> transfer(dbus_transfer);
-  m_model->add(transfer);
-
-  // notify the model whenever the Transfer changes
-  const auto id = dbus_transfer->id;
-  dbus_transfer->changed().connect([this,id]{
-    if (m_model->get(id))
-      m_model->emit_changed(id);
-  });
-}
-
-namespace
-{
-  std::shared_ptr<DBusTransfer>
-  get_dbus_transfer(const std::shared_ptr<Model>& model, const Transfer::Id& id)
-  {
-    auto transfer = model->get(id);
+  }
+
+  void start(const Transfer::Id& id)
+  {
+    auto transfer = find_transfer_by_id(id);
+    g_return_if_fail(transfer);
+    transfer->start();
+  }
+
+  void pause(const Transfer::Id& id)
+  {
+    auto transfer = find_transfer_by_id(id);
+    g_return_if_fail(transfer);
+    transfer->pause();
+  }
+
+  void resume(const Transfer::Id& id)
+  {
+    auto transfer = find_transfer_by_id(id);
+    g_return_if_fail(transfer);
+    transfer->resume();
+  }
+
+  void cancel(const Transfer::Id& id)
+  {
+    auto transfer = find_transfer_by_id(id);
+    g_return_if_fail(transfer);
+    transfer->cancel();
+  }
+
+  void open(const Transfer::Id& id)
+  {
+    auto transfer = find_transfer_by_id(id);
+    g_return_if_fail(transfer);
+    transfer->open();
+    transfer->open_app();
+  }
+
+  void open_app(const Transfer::Id& id)
+  {
+    auto transfer = find_transfer_by_id(id);
+    g_return_if_fail(transfer);
+    transfer->open_app();
+  }
+
+private:
+
+  static void on_bus_ready(GObject        * /*source_object*/,
+                           GAsyncResult   * res,
+                           gpointer       gself)
+  {
+    GError* error = nullptr;
+    auto bus = g_bus_get_finish(res, &error);
+
+    if (bus == nullptr)
+      {
+        if (!g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+          g_warning("Could not get session bus: %s", error->message);
+
+        g_error_free(error);
+      }
+    else
+      {
+        static_cast<Impl*>(gself)->set_bus(bus);
+        g_object_unref(bus);
+      }
+  }
+
+  void set_bus(GDBusConnection* bus)
+  {
+    if (m_bus != nullptr)
+      {
+        for (const auto& tag : m_signal_subscriptions)
+          g_dbus_connection_signal_unsubscribe(m_bus, tag);
+
+        m_signal_subscriptions.clear();
+        g_clear_object(&m_bus);
+      }
+
+    if (bus != nullptr)
+      {
+        g_debug("%s: %s", G_STRFUNC, g_dbus_connection_get_unique_name(bus));
+        m_bus = G_DBUS_CONNECTION(g_object_ref(bus));
+
+        guint tag;
+
+        tag = g_dbus_connection_signal_subscribe(bus,
+                                                 DM_BUS_NAME,
+                                                 DM_DOWNLOAD_IFACE_NAME,
+                                                 nullptr,
+                                                 nullptr,
+                                                 nullptr,
+                                                 G_DBUS_SIGNAL_FLAGS_NONE,
+                                                 on_download_signal,
+                                                 this,
+                                                 nullptr);
+        m_signal_subscriptions.insert(tag);
+
+        tag = g_dbus_connection_signal_subscribe(bus,
+                                                 CH_BUS_NAME,
+                                                 CH_TRANSFER_IFACE_NAME,
+                                                 nullptr,
+                                                 nullptr,
+                                                 nullptr,
+                                                 G_DBUS_SIGNAL_FLAGS_NONE,
+                                                 on_transfer_signal_static,
+                                                 this,
+                                                 nullptr);
+        m_signal_subscriptions.insert(tag);
+      }
+  }
+
+  static void on_transfer_signal_static(GDBusConnection* /*connection*/,
+                                        const gchar*     /*sender_name*/,
+                                        const gchar*       object_path,
+                                        const gchar*     /*interface_name*/,
+                                        const gchar*       signal_name,
+                                        GVariant*          parameters,
+                                        gpointer           gself)
+  {
+    static_cast<Impl*>(gself)->on_transfer_signal(object_path, signal_name, parameters);
+  }
+
+  void on_transfer_signal(const gchar* cucdt_path,
+                          const gchar* signal_name,
+                          GVariant* parameters)
+  {
+    g_debug("transfer signal: %s %s %s", cucdt_path, signal_name, g_variant_print(parameters, TRUE));
+
+    if (!g_strcmp0(signal_name, "DownloadIdChanged"))
+      {
+        const char* ccad_path = nullptr;
+        g_variant_get_child(parameters, 0, "&s", &ccad_path);
+        g_return_if_fail(cucdt_path != nullptr);
+
+        // ensure this ccad/cucdt pair is tracked
+        if (!find_transfer_by_ccad_path(ccad_path))
+          create_new_transfer(ccad_path, cucdt_path);
+      }
+    else
+      {
+        // Route this signal to the DBusTransfer for processing
+        auto transfer = find_transfer_by_cucdt_path(cucdt_path);
+        if (transfer)
+          transfer->handle_cucdt_signal(signal_name, parameters);
+      }
+  }
+
+  static void on_download_signal(GDBusConnection* /*connection*/,
+                                 const gchar*     /*sender_name*/,
+                                 const gchar*       ccad_path,
+                                 const gchar*     /*interface_name*/,
+                                 const gchar*       signal_name,
+                                 GVariant*          parameters,
+                                 gpointer           gself)
+  {
+    g_debug("download signal: %s %s %s", ccad_path, signal_name, g_variant_print(parameters, TRUE));
+
+    // Route this signal to the DBusTransfer for processing 
+    auto self = static_cast<Impl*>(gself);
+    auto transfer = self->find_transfer_by_ccad_path(ccad_path);
+    if (transfer)
+      transfer->handle_ccad_signal(signal_name, parameters);
+  }
+
+  /***
+  ****
+  ***/
+
+  std::shared_ptr<DBusTransfer> find_transfer_by_ccad_path(const std::string& path)
+  {
+    for (const auto& transfer : m_model->get_all())
+      {
+        const auto tmp = std::static_pointer_cast<DBusTransfer>(transfer);
+
+        if (tmp && (path == tmp->ccad_path()))
+          return tmp;
+      }
+
+    return nullptr;
+  }
+
+  std::shared_ptr<DBusTransfer> find_transfer_by_cucdt_path(const std::string& path)
+  {
+    for (const auto& transfer : m_model->get_all())
+      {
+        const auto tmp = std::static_pointer_cast<DBusTransfer>(transfer);
+
+        if (tmp && (path == tmp->cucdt_path()))
+          return tmp;
+      }
+
+    return nullptr;
+  }
+
+  void create_new_transfer(const std::string& ccad_path,
+                           const std::string& cucdt_path)
+  {
+    // don't let transfers reappear after they've been cleared by the user
+    if (m_removed_ccad.count(ccad_path))
+      return;
+
+    auto new_transfer = std::make_shared<DBusTransfer>(m_bus, ccad_path, cucdt_path);
+
+    m_model->add(new_transfer);
+
+    // when one of the DBusTransfer's properties changes,
+    // emit a change signal for the model
+    const auto id = new_transfer->id;
+    new_transfer->changed().connect([this,id]{
+      if (m_model->get(id))
+        m_model->emit_changed(id);
+    });
+  }
+
+  std::shared_ptr<DBusTransfer> find_transfer_by_id(const Transfer::Id& id)
+  {
+    auto transfer = m_model->get(id);
     g_return_val_if_fail(transfer, std::shared_ptr<DBusTransfer>());
     return std::static_pointer_cast<DBusTransfer>(transfer);
   }
-}
-
-void DBusWorld::start(const Transfer::Id& id)
-{
-  auto dbus_transfer = get_dbus_transfer (m_model, id);
-  g_return_if_fail(dbus_transfer);
-  dbus_transfer->start();
-}
-
-void DBusWorld::pause(const Transfer::Id& id)
-{
-  auto dbus_transfer = get_dbus_transfer (m_model, id);
-  g_return_if_fail(dbus_transfer);
-  dbus_transfer->pause();
-}
-
-void DBusWorld::resume(const Transfer::Id& id)
-{
-  auto dbus_transfer = get_dbus_transfer (m_model, id);
-  g_return_if_fail(dbus_transfer);
-  dbus_transfer->resume();
-}
-
-void DBusWorld::cancel(const Transfer::Id& id)
-{
-  auto dbus_transfer = get_dbus_transfer (m_model, id);
-  g_return_if_fail(dbus_transfer);
-  dbus_transfer->cancel();
-}
-
-void DBusWorld::open(const Transfer::Id& id)
-{
-  std::cerr << G_STRFUNC << " FIXME " << id << std::endl;
-}
-
-void DBusWorld::open_app(const Transfer::Id& id)
-{
-  std::cerr << G_STRFUNC << " FIXME " << id << std::endl;
+
+  GDBusConnection* m_bus = nullptr;
+  GCancellable* m_cancellable = nullptr;
+  std::set<guint> m_signal_subscriptions;
+  std::shared_ptr<MutableModel> m_model;
+  std::set<std::string> m_removed_ccad;
+};
+
+/***
+****
+***/
+
+DBusWorld::DBusWorld(const std::shared_ptr<MutableModel>& model):
+  impl(new Impl(model))
+{
+}
+
+DBusWorld::~DBusWorld()
+{
+}
+
+void
+DBusWorld::open(const Transfer::Id& id)
+{
+  impl->open(id);
+}
+
+void
+DBusWorld::start(const Transfer::Id& id)
+{
+  impl->start(id);
+}
+
+void
+DBusWorld::pause(const Transfer::Id& id)
+{
+  impl->pause(id);
+}
+
+void
+DBusWorld::resume(const Transfer::Id& id)
+{
+  impl->resume(id);
+}
+
+void
+DBusWorld::cancel(const Transfer::Id& id)
+{
+  impl->cancel(id);
+}
+
+void
+DBusWorld::open_app(const Transfer::Id& id)
+{
+  impl->open_app(id);
 }
 
 /***

=== modified file 'tests/manual'
--- tests/manual	2014-06-18 15:26:37 +0000
+++ tests/manual	2014-08-26 20:52:17 +0000
@@ -1,23 +1,23 @@
 
-Test-case indicator-transfer/simple-download-check
+Test-case indicator-transfer/download-an-image
 <dl>
     <dt>Ensure indicator-transfer-service is running<dt>
-            <dd>The indicator should be visible in the panel</dd>
-
-            <dt>Run the script tests/simple-download.py and, immediately afterwards,
-                click or pull down on the indicator so that its menu is visible
-                and its menuitems can be observed while the downloads run.</dt>
-                    <dd>In the 'Ongoing Transfers' section, the transfers should appear</dd>
-                    <dd>In the 'Ongoing Transfers' section, a 'Pause all' button should appear</dd>
-                    <dd>While transfers are active, the indicator's icon should indicate activity</dd>
-                    <dd>As each transfer finishes, its menuitem should move from the 'Ongoing' to 'Successful' section</dd>
-                    <dd>As the first transfer is moved to the 'Successful' section, a 'Clear all' button should appear</dd>
-                    <dd>As the last transfer finishes, the indicator's icon should change to indicate an idle state</dd>
-                    <dd>As the last transfer finishes, the 'Pause all' button should disappear</dd>
-
-            <dt>After all the transfers finish, press the 'Clear all' button.</dt>
-                    <dd>All three transfers should be cleared from the menu.</dd>
-                    <dd>The 'Clear all' button should disappear</dd>
+        <dd>The indicator should be visible in the panel</dd>
+    <dt>Start downloading an image from the Browser to the Gallery.
+        (In the Browser, tap-and-hold on an image, choose 'Save image'
+        in the popup, and select 'Gallery' at the 'Open with ' prompt.</dt>
+        <dd>In the 'Ongoing Transfers' section, the transfer should appear</dd>
+        <dd>In the 'Ongoing Transfers' section, a 'Pause all' button should appear</dd>
+        <dd>While transfer is active, the indicator's icon should indicate activity</dd>
+        <dd>While transfer is active, the menuitem's progressbar should show its progress</dd>
+        <dd>As the transfer finishes, its menuitem should move from the 'Ongoing' to 'Successful' section</dd>
+        <dd>As the transfer finishes, the indicator's icon should change to indicate an idle state</dd>
+        <dd>As the transfer finishes, the 'Pause all' button should disappear</dd>
+    <dt>Click on the completed transfer's menuitem</dt>
+        <dd>The gallery app should launch</dd>
+    <dt>Press the 'Clear all' button.</dt>
+        <dd>The transfer should be cleared from the menu.</dd>
+        <dd>The 'Clear all' button should disappear</dd>
 </dt>
 
 <strong>