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_API_ATTACHMENTS_ATTACHMENT_SERVICE_PROXY_H_ 6 #define SYNC_API_ATTACHMENTS_ATTACHMENT_SERVICE_PROXY_H_ 7 8 #include "base/basictypes.h" 9 #include "base/callback.h" 10 #include "base/memory/scoped_ptr.h" 11 #include "base/memory/weak_ptr.h" 12 #include "base/sequenced_task_runner.h" 13 #include "base/task_runner.h" 14 #include "sync/api/attachments/attachment.h" 15 #include "sync/api/attachments/attachment_service.h" 16 #include "sync/base/sync_export.h" 17 18 namespace syncer { 19 20 class SyncData; 21 22 // AttachmentServiceProxy wraps an AttachmentService allowing multiple threads 23 // to share the wrapped AttachmentService and invoke its methods in the 24 // appropriate thread. 25 // 26 // Callbacks passed to methods on this class will be invoked in the same thread 27 // from which the method was called. 28 // 29 // This class does not own its wrapped AttachmentService object. This class 30 // holds a WeakPtr to the wrapped object. Once the the wrapped object is 31 // destroyed, method calls on this object will be no-ops. 32 // 33 // Users of this class should take care to destroy the wrapped object on the 34 // correct thread (wrapped_task_runner). 35 // 36 // This class is thread-safe and is designed to be passed by const-ref. 37 class SYNC_EXPORT AttachmentServiceProxy : public AttachmentService { 38 public: 39 // Default copy and assignment are welcome. 40 41 // Construct an invalid AttachmentServiceProxy. 42 AttachmentServiceProxy(); 43 44 // Construct an AttachmentServiceProxy that forwards calls to |wrapped| on the 45 // |wrapped_task_runner| thread. 46 // 47 // Note, this object does not own |wrapped|. When |wrapped| is destroyed, 48 // calls to this object become no-ops. 49 AttachmentServiceProxy( 50 const scoped_refptr<base::SequencedTaskRunner>& wrapped_task_runner, 51 const base::WeakPtr<syncer::AttachmentService>& wrapped); 52 53 virtual ~AttachmentServiceProxy(); 54 55 // AttachmentService implementation. 56 virtual void GetOrDownloadAttachments( 57 const AttachmentIdList& attachment_ids, 58 const GetOrDownloadCallback& callback) OVERRIDE; 59 virtual void DropAttachments(const AttachmentIdList& attachment_ids, 60 const DropCallback& callback) OVERRIDE; 61 virtual void StoreAttachments(const AttachmentList& attachment, 62 const StoreCallback& callback) OVERRIDE; 63 virtual void OnSyncDataDelete(const SyncData& sync_data) OVERRIDE; 64 virtual void OnSyncDataUpdate(const AttachmentIdList& old_attachment_ids, 65 const SyncData& updated_sync_data) OVERRIDE; 66 67 protected: 68 // Core does the work of proxying calls to AttachmentService methods from one 69 // thread to another so AttachmentServiceProxy can be an easy-to-use, 70 // non-ref-counted A ref-counted class. 71 // 72 // Callback from AttachmentService are proxied back using free functions 73 // defined in the .cc file (ProxyFooCallback functions). 74 // 75 // Core is ref-counted because we want to allow AttachmentServiceProxy to be 76 // copy-constructable while allowing for different implementations of Core 77 // (e.g. one type of core might own the wrapped AttachmentService). 78 // 79 // Calls to objects of this class become no-ops once its wrapped object is 80 // destroyed. 81 class SYNC_EXPORT Core : public AttachmentService, 82 public base::RefCountedThreadSafe<Core> { 83 public: 84 // Construct an AttachmentServiceProxyCore that forwards calls to |wrapped|. 85 Core(const base::WeakPtr<syncer::AttachmentService>& wrapped); 86 87 // AttachmentService implementation. 88 virtual void GetOrDownloadAttachments( 89 const AttachmentIdList& attachment_ids, 90 const GetOrDownloadCallback& callback) OVERRIDE; 91 virtual void DropAttachments(const AttachmentIdList& attachment_ids, 92 const DropCallback& callback) OVERRIDE; 93 virtual void StoreAttachments(const AttachmentList& attachment, 94 const StoreCallback& callback) OVERRIDE; 95 virtual void OnSyncDataDelete(const SyncData& sync_data) OVERRIDE; 96 virtual void OnSyncDataUpdate(const AttachmentIdList& old_attachment_ids, 97 const SyncData& updated_sync_data) OVERRIDE; 98 99 protected: 100 friend class base::RefCountedThreadSafe<Core>; 101 virtual ~Core(); 102 103 private: 104 base::WeakPtr<AttachmentService> wrapped_; 105 106 DISALLOW_COPY_AND_ASSIGN(Core); 107 }; 108 109 // Used in tests to create an AttachmentServiceProxy with a custom Core. 110 AttachmentServiceProxy( 111 const scoped_refptr<base::SequencedTaskRunner>& wrapped_task_runner, 112 const scoped_refptr<Core>& core); 113 114 private: 115 scoped_refptr<base::SequencedTaskRunner> wrapped_task_runner_; 116 scoped_refptr<Core> core_; 117 }; 118 119 } // namespace syncer 120 121 #endif // SYNC_API_ATTACHMENTS_ATTACHMENT_SERVICE_PROXY_H_ 122