mock_file_stream.cc 4.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127
  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. #include "net/base/mock_file_stream.h"
  5. #include <utility>
  6. #include "base/bind.h"
  7. #include "base/location.h"
  8. #include "base/task/single_thread_task_runner.h"
  9. #include "base/threading/thread_task_runner_handle.h"
  10. namespace net::testing {
  11. MockFileStream::MockFileStream(
  12. const scoped_refptr<base::TaskRunner>& task_runner)
  13. : FileStream(task_runner) {}
  14. MockFileStream::MockFileStream(
  15. base::File file,
  16. const scoped_refptr<base::TaskRunner>& task_runner)
  17. : FileStream(std::move(file), task_runner) {}
  18. MockFileStream::~MockFileStream() = default;
  19. int MockFileStream::Seek(int64_t offset, Int64CompletionOnceCallback callback) {
  20. Int64CompletionOnceCallback wrapped_callback =
  21. base::BindOnce(&MockFileStream::DoCallback64, weak_factory_.GetWeakPtr(),
  22. std::move(callback));
  23. if (forced_error_ == OK)
  24. return FileStream::Seek(offset, std::move(wrapped_callback));
  25. return ErrorCallback64(std::move(wrapped_callback));
  26. }
  27. int MockFileStream::Read(IOBuffer* buf,
  28. int buf_len,
  29. CompletionOnceCallback callback) {
  30. CompletionOnceCallback wrapped_callback =
  31. base::BindOnce(&MockFileStream::DoCallback, weak_factory_.GetWeakPtr(),
  32. std::move(callback));
  33. if (forced_error_ == OK)
  34. return FileStream::Read(buf, buf_len, std::move(wrapped_callback));
  35. return ErrorCallback(std::move(wrapped_callback));
  36. }
  37. int MockFileStream::Write(IOBuffer* buf,
  38. int buf_len,
  39. CompletionOnceCallback callback) {
  40. CompletionOnceCallback wrapped_callback =
  41. base::BindOnce(&MockFileStream::DoCallback, weak_factory_.GetWeakPtr(),
  42. std::move(callback));
  43. if (forced_error_ == OK)
  44. return FileStream::Write(buf, buf_len, std::move(wrapped_callback));
  45. return ErrorCallback(std::move(wrapped_callback));
  46. }
  47. int MockFileStream::Flush(CompletionOnceCallback callback) {
  48. CompletionOnceCallback wrapped_callback =
  49. base::BindOnce(&MockFileStream::DoCallback, weak_factory_.GetWeakPtr(),
  50. std::move(callback));
  51. if (forced_error_ == OK)
  52. return FileStream::Flush(std::move(wrapped_callback));
  53. return ErrorCallback(std::move(wrapped_callback));
  54. }
  55. void MockFileStream::ThrottleCallbacks() {
  56. CHECK(!throttled_);
  57. throttled_ = true;
  58. }
  59. void MockFileStream::ReleaseCallbacks() {
  60. CHECK(throttled_);
  61. throttled_ = false;
  62. if (!throttled_task_.is_null()) {
  63. base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
  64. std::move(throttled_task_));
  65. }
  66. }
  67. void MockFileStream::DoCallback(CompletionOnceCallback callback, int result) {
  68. if (!throttled_) {
  69. std::move(callback).Run(result);
  70. return;
  71. }
  72. CHECK(throttled_task_.is_null());
  73. throttled_task_ = base::BindOnce(std::move(callback), result);
  74. }
  75. void MockFileStream::DoCallback64(Int64CompletionOnceCallback callback,
  76. int64_t result) {
  77. if (!throttled_) {
  78. std::move(callback).Run(result);
  79. return;
  80. }
  81. CHECK(throttled_task_.is_null());
  82. throttled_task_ = base::BindOnce(std::move(callback), result);
  83. }
  84. int MockFileStream::ErrorCallback(CompletionOnceCallback callback) {
  85. CHECK_NE(OK, forced_error_);
  86. if (async_error_) {
  87. base::ThreadTaskRunnerHandle::Get()->PostTask(
  88. FROM_HERE, base::BindOnce(std::move(callback), forced_error_));
  89. clear_forced_error();
  90. return ERR_IO_PENDING;
  91. }
  92. int ret = forced_error_;
  93. clear_forced_error();
  94. return ret;
  95. }
  96. int64_t MockFileStream::ErrorCallback64(Int64CompletionOnceCallback callback) {
  97. CHECK_NE(OK, forced_error_);
  98. if (async_error_) {
  99. base::ThreadTaskRunnerHandle::Get()->PostTask(
  100. FROM_HERE, base::BindOnce(std::move(callback), forced_error_));
  101. clear_forced_error();
  102. return ERR_IO_PENDING;
  103. }
  104. int64_t ret = forced_error_;
  105. clear_forced_error();
  106. return ret;
  107. }
  108. } // namespace net::testing