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