Merge TestResourceHandlers used by two different test fixtures.

content/browser/loader/intercepting_resource_handler_unittest.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/loader/intercepting_resource_handler.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <string>
 
 #include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
+#include "content/browser/loader/test_resource_handler.h"
 #include "content/public/browser/resource_controller.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/common/resource_response.h"
 #include "content/public/common/webplugininfo.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/public/test/test_utils.h"
 #include "net/base/net_errors.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_status.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 12 matching lines @@
   void Resume() override { ++resume_calls_; }
 
   int resume_calls() const { return resume_calls_; }
 
  private:
   int resume_calls_ = 0;
 
   DISALLOW_COPY_AND_ASSIGN(TestResourceController);
 };
 
-// TODO(yhirano): This class should use a similar pattern with
-// TestResourceHandler in mime_sniffing_resource_handler_unittest.cc. Consider
-// unifying the two classes.
-class TestResourceHandler : public ResourceHandler {
- public:
-  // A test version of a ResourceHandler. |request_status| will be updated when
-  // the response is complete with the final status of the request received by
-  // the handler and |body| will be updated on each OnReadCompleted call.
-  explicit TestResourceHandler(net::URLRequestStatus* request_status,
-                               std::string* body)
-      : ResourceHandler(nullptr), request_status_(request_status), body_(body) {
-    SetBufferSize(2048);
-  }
-
-  ~TestResourceHandler() override {}
-
-  void SetController(ResourceController* controller) override {}
-
-  bool OnRequestRedirected(const net::RedirectInfo& redirect_info,
-                           ResourceResponse* response,
-                           bool* defer) override {
-    NOTREACHED();
-    return false;
-  }
-
-  bool OnResponseStarted(ResourceResponse* response, bool* defer) override {
-    EXPECT_TRUE(will_start_called_);
-    EXPECT_FALSE(response_started_called_);
-    EXPECT_FALSE(response_completed_called_);
-    response_started_called_ = true;
-
-    if (!on_response_started_result_)
-      return false;
-    *defer = defer_on_response_started_;
-    defer_on_response_started_ = false;
-    return true;
-  }
-
-  bool OnWillStart(const GURL& url, bool* defer) override {
-    EXPECT_FALSE(response_started_called_);
-    EXPECT_FALSE(will_start_called_);
-    EXPECT_FALSE(response_completed_called_);
-    will_start_called_ = true;
-
-    if (!on_will_start_result_)
-      return false;
-
-    *defer = defer_on_will_start_;
-    return true;
-  }
-
-  bool OnWillRead(scoped_refptr<net::IOBuffer>* buf,
-                  int* buf_size,
-                  int min_size) override {
-    EXPECT_FALSE(response_completed_called_);
-
-    *buf = buffer_;
-    *buf_size = buffer_size_;
-    memset(buffer_->data(), '\0', buffer_size_);
-    return on_will_read_result_;
-  }
-
-  bool OnReadCompleted(int bytes_read, bool* defer) override {
-    EXPECT_TRUE(will_start_called_);
-    EXPECT_TRUE(response_started_called_);
-    EXPECT_FALSE(response_completed_called_);
-
-    EXPECT_LE(static_cast<size_t>(bytes_read), buffer_size_);
-    body_->append(buffer_->data(), bytes_read);
-    if (!on_read_completed_result_)
-      return false;
-    *defer = defer_on_read_completed_;
-    defer_on_read_completed_ = false;
-    return true;
-  }
-
-  void OnResponseCompleted(const net::URLRequestStatus& status,
-                           bool* defer) override {
-    EXPECT_FALSE(response_completed_called_);
-    response_completed_called_ = true;
-    *request_status_ = status;
-    *defer = defer_on_response_completed_;
-    defer_on_response_completed_ = false;
-  }
-
-  void OnDataDownloaded(int bytes_downloaded) override { NOTREACHED(); }
-
-  scoped_refptr<net::IOBuffer> buffer() const { return buffer_; }
-
-  // Sets the size of the read buffer returned by OnWillRead. Releases reference
-  // to previous read buffer.
-  void SetBufferSize(int buffer_size) {
-    buffer_ = new net::IOBuffer(buffer_size);
-    buffer_size_ = buffer_size;
-    memset(buffer_->data(), '\0', buffer_size);
-  }
-
-  void set_on_will_start_result(bool on_will_start_result) {
-    on_will_start_result_ = on_will_start_result;
-  }
-  void set_on_response_started_result(bool on_response_started_result) {
-    on_response_started_result_ = on_response_started_result;
-  }
-  void set_on_will_read_result(bool on_will_read_result) {
-    on_will_read_result_ = on_will_read_result;
-  }
-  void set_on_read_completed_result(bool on_read_completed_result) {
-    on_read_completed_result_ = on_read_completed_result;
-  }
-
-  void set_defer_on_will_start(bool defer_on_will_start) {
-    defer_on_will_start_ = defer_on_will_start;
-  }
-  void set_defer_on_response_started(bool defer_on_response_started) {
-    defer_on_response_started_ = defer_on_response_started;
-  }
-  void set_defer_on_read_completed(bool defer_on_read_completed) {
-    defer_on_read_completed_ = defer_on_read_completed;
-  }
-  void set_defer_on_response_completed(bool defer_on_response_completed) {
-    defer_on_response_completed_ = defer_on_response_completed;
-  }
-
- private:
-  net::URLRequestStatus* request_status_;
-  std::string* body_;
-  scoped_refptr<net::IOBuffer> buffer_;
-  size_t buffer_size_;
-
-  bool on_will_start_result_ = true;
-  bool on_response_started_result_ = true;
-  bool on_will_read_result_ = true;
-  bool on_read_completed_result_ = true;
-
-  bool defer_on_will_start_ = false;
-  bool defer_on_response_started_ = false;
-  bool defer_on_read_completed_ = false;
-  bool defer_on_response_completed_ = false;
-
-  bool will_start_called_ = false;
-  bool response_started_called_ = false;
-  bool response_completed_called_ = false;
-
-  DISALLOW_COPY_AND_ASSIGN(TestResourceHandler);
-};
-
 class InterceptingResourceHandlerTest : public testing::Test {
  public:
   InterceptingResourceHandlerTest() {}
 
  private:
   TestBrowserThreadBundle thread_bundle_;
 };
 
 // Tests that the handler behaves properly when it doesn't have to use an
 // alternate next handler.
@@ skipping 817 matching lines @@
       {net::URLRequestStatus::CANCELED, net::ERR_FAILED}, &defer);
   ASSERT_TRUE(defer);
   EXPECT_EQ(0, resource_controller->resume_calls());
   EXPECT_EQ(net::URLRequestStatus::CANCELED, old_handler_status.status());
   EXPECT_EQ(net::URLRequestStatus::CANCELED, new_handler_status.status());
 }
 
 }  // namespace
 
 }  // namespace content