net/base/mock_file_stream.cc

   1 // Copyright (c) 2012 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 "net/base/mock_file_stream.h"
   6
   7 #include "base/bind.h"
   8 #include "base/location.h"
   9 #include "base/single_thread_task_runner.h"
  10 #include "base/thread_task_runner_handle.h"
  11
  12 namespace net {
  13
  14 namespace testing {
  15
  16 MockFileStream::MockFileStream(
  17     const scoped_refptr<base::TaskRunner>& task_runner)
  18     : FileStream(task_runner),
  19       forced_error_(OK),
  20       async_error_(false),
  21       throttled_(false),
  22       weak_factory_(this) {
  23 }
  24
  25 MockFileStream::MockFileStream(
  26     base::File file,
  27     const scoped_refptr<base::TaskRunner>& task_runner)
  28     : FileStream(file.Pass(), task_runner),
  29       forced_error_(OK),
  30       async_error_(false),
  31       throttled_(false),
  32       weak_factory_(this) {
  33 }
  34
  35 MockFileStream::~MockFileStream() {
  36 }
  37
  38 int MockFileStream::Seek(base::File::Whence whence,
  39                          int64_t offset,
  40                          const Int64CompletionCallback& callback) {
  41   Int64CompletionCallback wrapped_callback =
  42       base::Bind(&MockFileStream::DoCallback64,
  43                  weak_factory_.GetWeakPtr(), callback);
  44   if (forced_error_ == OK)
  45     return FileStream::Seek(whence, offset, wrapped_callback);
  46   return ErrorCallback64(wrapped_callback);
  47 }
  48
  49 int MockFileStream::Read(IOBuffer* buf,
  50                          int buf_len,
  51                          const CompletionCallback& callback) {
  52   CompletionCallback wrapped_callback = base::Bind(&MockFileStream::DoCallback,
  53                                                    weak_factory_.GetWeakPtr(),
  54                                                    callback);
  55   if (forced_error_ == OK)
  56     return FileStream::Read(buf, buf_len, wrapped_callback);
  57   return ErrorCallback(wrapped_callback);
  58 }
  59
  60 int MockFileStream::Write(IOBuffer* buf,
  61                           int buf_len,
  62                           const CompletionCallback& callback) {
  63   CompletionCallback wrapped_callback = base::Bind(&MockFileStream::DoCallback,
  64                                                    weak_factory_.GetWeakPtr(),
  65                                                    callback);
  66   if (forced_error_ == OK)
  67     return FileStream::Write(buf, buf_len, wrapped_callback);
  68   return ErrorCallback(wrapped_callback);
  69 }
  70
  71 int MockFileStream::Flush(const CompletionCallback& callback) {
  72   CompletionCallback wrapped_callback = base::Bind(&MockFileStream::DoCallback,
  73                                                    weak_factory_.GetWeakPtr(),
  74                                                    callback);
  75   if (forced_error_ == OK)
  76     return FileStream::Flush(wrapped_callback);
  77   return ErrorCallback(wrapped_callback);
  78 }
  79
  80 void MockFileStream::ThrottleCallbacks() {
  81   CHECK(!throttled_);
  82   throttled_ = true;
  83 }
  84
  85 void MockFileStream::ReleaseCallbacks() {
  86   CHECK(throttled_);
  87   throttled_ = false;
  88
  89   if (!throttled_task_.is_null()) {
  90     base::Closure throttled_task = throttled_task_;
  91     throttled_task_.Reset();
  92     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, throttled_task);
  93   }
  94 }
  95
  96 void MockFileStream::DoCallback(const CompletionCallback& callback,
  97                                 int result) {
  98   if (!throttled_) {
  99     callback.Run(result);
 100     return;
 101   }
 102   CHECK(throttled_task_.is_null());
 103   throttled_task_ = base::Bind(callback, result);
 104 }
 105
 106 void MockFileStream::DoCallback64(const Int64CompletionCallback& callback,
 107                                   int64_t result) {
 108   if (!throttled_) {
 109     callback.Run(result);
 110     return;
 111   }
 112   CHECK(throttled_task_.is_null());
 113   throttled_task_ = base::Bind(callback, result);
 114 }
 115
 116 int MockFileStream::ErrorCallback(const CompletionCallback& callback) {
 117   CHECK_NE(OK, forced_error_);
 118   if (async_error_) {
 119     base::ThreadTaskRunnerHandle::Get()->PostTask(
 120         FROM_HERE, base::Bind(callback, forced_error_));
 121     clear_forced_error();
 122     return ERR_IO_PENDING;
 123   }
 124   int ret = forced_error_;
 125   clear_forced_error();
 126   return ret;
 127 }
 128
 129 int64_t MockFileStream::ErrorCallback64(
 130     const Int64CompletionCallback& callback) {
 131   CHECK_NE(OK, forced_error_);
 132   if (async_error_) {
 133     base::ThreadTaskRunnerHandle::Get()->PostTask(
 134         FROM_HERE, base::Bind(callback, forced_error_));
 135     clear_forced_error();
 136     return ERR_IO_PENDING;
 137   }
 138   int64_t ret = forced_error_;
 139   clear_forced_error();
 140   return ret;
 141 }
 142
 143 }  // namespace testing
 144
 145 }  // namespace net