sync/internal_api/public/attachments/attachment_service_impl.h

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef SYNC_INTERNAL_API_PUBLIC_ATTACHMENTS_ATTACHMENT_SERVICE_IMPL_H_
   6 #define SYNC_INTERNAL_API_PUBLIC_ATTACHMENTS_ATTACHMENT_SERVICE_IMPL_H_
   7
   8 #include <deque>
   9
  10 #include "base/memory/ref_counted.h"
  11 #include "base/memory/weak_ptr.h"
  12 #include "base/threading/non_thread_safe.h"
  13 #include "net/base/network_change_notifier.h"
  14 #include "sync/api/attachments/attachment_store.h"
  15 #include "sync/internal_api/public/attachments/attachment_downloader.h"
  16 #include "sync/internal_api/public/attachments/attachment_service.h"
  17 #include "sync/internal_api/public/attachments/attachment_service_proxy.h"
  18 #include "sync/internal_api/public/attachments/attachment_uploader.h"
  19 #include "sync/internal_api/public/attachments/task_queue.h"
  20
  21 namespace syncer {
  22
  23 // Implementation of AttachmentService.
  24 class SYNC_EXPORT AttachmentServiceImpl
  25     : public AttachmentService,
  26       public net::NetworkChangeNotifier::NetworkChangeObserver,
  27       public base::NonThreadSafe {
  28  public:
  29   // |attachment_store| is required. UploadAttachments reads attachment data
  30   // from it. Downloaded attachments will be written into it.
  31   //
  32   // |attachment_uploader| is optional. If null, attachments will never be
  33   // uploaded to the sync server and |delegate|'s OnAttachmentUploaded will
  34   // never be invoked.
  35   //
  36   // |attachment_downloader| is optional. If null, attachments will never be
  37   // downloaded. Only attachments in |attachment_store| will be returned from
  38   // GetOrDownloadAttachments.
  39   //
  40   // |delegate| is optional delegate for AttachmentService to notify about
  41   // asynchronous events (AttachmentUploaded). Pass NULL if delegate is not
  42   // provided. AttachmentService doesn't take ownership of delegate, the pointer
  43   // must be valid throughout AttachmentService lifetime.
  44   //
  45   // |initial_backoff_delay| the initial delay between upload attempts.  This
  46   // class automatically retries failed uploads.  After the first failure, it
  47   // will wait this amount of time until it tries again.  After each failure,
  48   // the delay is doubled until the |max_backoff_delay| is reached.  A
  49   // successful upload clears the delay.
  50   //
  51   // |max_backoff_delay| the maxmium delay between upload attempts when backed
  52   // off.
  53   AttachmentServiceImpl(scoped_ptr<AttachmentStoreForSync> attachment_store,
  54                         scoped_ptr<AttachmentUploader> attachment_uploader,
  55                         scoped_ptr<AttachmentDownloader> attachment_downloader,
  56                         Delegate* delegate,
  57                         const base::TimeDelta& initial_backoff_delay,
  58                         const base::TimeDelta& max_backoff_delay);
  59   ~AttachmentServiceImpl() override;
  60
  61   // Create an AttachmentServiceImpl suitable for use in tests.
  62   static scoped_ptr<syncer::AttachmentService> CreateForTest();
  63
  64   // AttachmentService implementation.
  65   void GetOrDownloadAttachments(const AttachmentIdList& attachment_ids,
  66                                 const GetOrDownloadCallback& callback) override;
  67   void UploadAttachments(const AttachmentIdList& attachment_ids) override;
  68
  69   // NetworkChangeObserver implementation.
  70   void OnNetworkChanged(
  71       net::NetworkChangeNotifier::ConnectionType type) override;
  72
  73   // Use |timer| in the underlying TaskQueue.
  74   //
  75   // Used in tests.  See also MockTimer.
  76   void SetTimerForTest(scoped_ptr<base::Timer> timer);
  77
  78  private:
  79   class GetOrDownloadState;
  80
  81   void ReadDone(const scoped_refptr<GetOrDownloadState>& state,
  82                 const AttachmentStore::Result& result,
  83                 scoped_ptr<AttachmentMap> attachments,
  84                 scoped_ptr<AttachmentIdList> unavailable_attachment_ids);
  85   void WriteDone(const scoped_refptr<GetOrDownloadState>& state,
  86                  const Attachment& attachment,
  87                  const AttachmentStore::Result& result);
  88   void UploadDone(const AttachmentUploader::UploadResult& result,
  89                   const AttachmentId& attachment_id);
  90   void DownloadDone(const scoped_refptr<GetOrDownloadState>& state,
  91                     const AttachmentId& attachment_id,
  92                     const AttachmentDownloader::DownloadResult& result,
  93                     scoped_ptr<Attachment> attachment);
  94   void BeginUpload(const AttachmentId& attachment_id);
  95   void ReadDoneNowUpload(
  96       const AttachmentStore::Result& result,
  97       scoped_ptr<AttachmentMap> attachments,
  98       scoped_ptr<AttachmentIdList> unavailable_attachment_ids);
  99
 100   scoped_ptr<AttachmentStoreForSync> attachment_store_;
 101
 102   // May be null.
 103   const scoped_ptr<AttachmentUploader> attachment_uploader_;
 104
 105   // May be null.
 106   const scoped_ptr<AttachmentDownloader> attachment_downloader_;
 107
 108   // May be null.
 109   Delegate* delegate_;
 110
 111   scoped_ptr<TaskQueue<AttachmentId> > upload_task_queue_;
 112
 113   // Must be last data member.
 114   base::WeakPtrFactory<AttachmentServiceImpl> weak_ptr_factory_;
 115
 116   DISALLOW_COPY_AND_ASSIGN(AttachmentServiceImpl);
 117 };
 118
 119 }  // namespace syncer
 120
 121 #endif  // SYNC_INTERNAL_API_PUBLIC_ATTACHMENTS_ATTACHMENT_SERVICE_IMPL_H_