sync/internal_api/attachments/attachment_service_proxy.cc

   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 #include "sync/internal_api/public/attachments/attachment_service_proxy.h"
   6
   7 #include "base/bind.h"
   8 #include "base/message_loop/message_loop.h"
   9 #include "base/thread_task_runner_handle.h"
  10
  11 namespace syncer {
  12
  13 namespace {
  14
  15 // These ProxyFooCallback functions are used to invoke a callback in a specific
  16 // thread.
  17
  18 // Invokes |callback| with |result| and |attachments| in the |task_runner|
  19 // thread.
  20 void ProxyGetOrDownloadCallback(
  21     const scoped_refptr<base::SequencedTaskRunner>& task_runner,
  22     const AttachmentService::GetOrDownloadCallback& callback,
  23     const AttachmentService::GetOrDownloadResult& result,
  24     scoped_ptr<AttachmentMap> attachments) {
  25   task_runner->PostTask(
  26       FROM_HERE, base::Bind(callback, result, base::Passed(&attachments)));
  27 }
  28
  29 }  // namespace
  30
  31 AttachmentServiceProxy::AttachmentServiceProxy() {
  32 }
  33
  34 AttachmentServiceProxy::AttachmentServiceProxy(
  35     const scoped_refptr<base::SequencedTaskRunner>& wrapped_task_runner,
  36     const base::WeakPtr<syncer::AttachmentService>& wrapped)
  37     : wrapped_task_runner_(wrapped_task_runner), core_(new Core(wrapped)) {
  38   DCHECK(wrapped_task_runner_.get());
  39 }
  40
  41 AttachmentServiceProxy::AttachmentServiceProxy(
  42     const scoped_refptr<base::SequencedTaskRunner>& wrapped_task_runner,
  43     const scoped_refptr<Core>& core)
  44     : wrapped_task_runner_(wrapped_task_runner), core_(core) {
  45   DCHECK(wrapped_task_runner_.get());
  46   DCHECK(core_.get());
  47 }
  48
  49 AttachmentServiceProxy::~AttachmentServiceProxy() {
  50 }
  51
  52 void AttachmentServiceProxy::GetOrDownloadAttachments(
  53     const AttachmentIdList& attachment_ids,
  54     const GetOrDownloadCallback& callback) {
  55   DCHECK(wrapped_task_runner_.get());
  56   GetOrDownloadCallback proxy_callback =
  57       base::Bind(&ProxyGetOrDownloadCallback,
  58                  base::ThreadTaskRunnerHandle::Get(),
  59                  callback);
  60   wrapped_task_runner_->PostTask(
  61       FROM_HERE,
  62       base::Bind(&AttachmentService::GetOrDownloadAttachments,
  63                  core_,
  64                  attachment_ids,
  65                  proxy_callback));
  66 }
  67
  68 void AttachmentServiceProxy::UploadAttachments(
  69     const AttachmentIdList& attachment_ids) {
  70   DCHECK(wrapped_task_runner_.get());
  71   wrapped_task_runner_->PostTask(
  72       FROM_HERE,
  73       base::Bind(&AttachmentService::UploadAttachments, core_, attachment_ids));
  74 }
  75
  76 AttachmentServiceProxy::Core::Core(
  77     const base::WeakPtr<syncer::AttachmentService>& wrapped)
  78     : wrapped_(wrapped) {
  79 }
  80
  81 AttachmentServiceProxy::Core::~Core() {
  82 }
  83
  84 void AttachmentServiceProxy::Core::GetOrDownloadAttachments(
  85     const AttachmentIdList& attachment_ids,
  86     const GetOrDownloadCallback& callback) {
  87   if (!wrapped_) {
  88     return;
  89   }
  90   wrapped_->GetOrDownloadAttachments(attachment_ids, callback);
  91 }
  92
  93 void AttachmentServiceProxy::Core::UploadAttachments(
  94     const AttachmentIdList& attachment_ids) {
  95   if (!wrapped_) {
  96     return;
  97   }
  98   wrapped_->UploadAttachments(attachment_ids);
  99 }
 100
 101 }  // namespace syncer