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