Move MimeTypeResourceHandler before ThrottlingResourceHandler

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 "base/files/file_path.h"
+#include "base/location.h"
+#include "base/logging.h"
+#include "base/macros.h"
+#include "base/single_thread_task_runner.h"
+#include "base/threading/thread_task_runner_handle.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/url_request/url_request_context.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "url/gurl.h"
+
+namespace content {
+
+namespace {
+
+class TestResourceHandler : public ResourceHandler {
+ public:
+  TestResourceHandler()
+      : ResourceHandler(nullptr), buffer_(new net::IOBuffer(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 {
+    return true;
+  }
+
+  bool OnWillStart(const GURL& url, bool* defer) override { return false; }
+
+  bool OnBeforeNetworkStart(const GURL& url, bool* defer) override {
+    NOTREACHED();
+    return false;
+  }
+
+  bool OnWillRead(scoped_refptr<net::IOBuffer>* buf,
+                  int* buf_size,
+                  int min_size) override {
+    *buf = buffer_;
+    *buf_size = 2048;
+    return true;
+  }
+
+  bool OnReadCompleted(int bytes_read, bool* defer) override {
+    DCHECK_LT(bytes_read, 2048);
+    return true;
+  }
+
+  void OnResponseCompleted(const net::URLRequestStatus& status,
+                           const std::string& security_info,
+                           bool* defer) override {}
+
+  void OnDataDownloaded(int bytes_downloaded) override { NOTREACHED(); }
+
+  scoped_refptr<net::IOBuffer> buffer() { return buffer_; }
+
+ private:
+  scoped_refptr<net::IOBuffer> buffer_;
+  DISALLOW_COPY_AND_ASSIGN(TestResourceHandler);
+};
+
+class InterceptingResourceHandlerTest : public testing::Test {
+ public:
+  InterceptingResourceHandlerTest() {}
+
+ private:
+  TestBrowserThreadBundle thread_bundle_;
+};
+
+// Tests that the data received is transmitted to the newly created
+// ResourceHandler.
+TEST_F(InterceptingResourceHandlerTest, ResponseBodyHandling) {

[mmenke, 2016/07/19 21:42:33]

Hrm...We aren't testing any of the failure cases (>OnResponseStarted returns
false, any of the three calls to OnWillRead returning false, or any of the two
calls to OnReadCompleted returning false).  Guess testing them is more effort
than it's worth.

[mmenke, 2016/07/19 21:42:33]

Seems like we should also test the non-intercept case, unexciting as it is.

[clamy, 2016/07/25 16:58:26]

Done. I only included some of the failure cases, since it turns out the current
code ignores the return values of the old ResourceHandler when calling
OnresponseStarted and OnReadCompleted.

+  net::URLRequestContext context;
+  std::unique_ptr<net::URLRequest> request(context.CreateRequest(
+      GURL("http://www.google.com"), net::DEFAULT_PRIORITY, nullptr));
+  ResourceRequestInfo::AllocateForTesting(request.get(),
+                                          RESOURCE_TYPE_MAIN_FRAME,
+                                          nullptr,  // context
+                                          0,        // render_process_id
+                                          0,        // render_view_id
+                                          0,        // render_frame_id
+                                          true,     // is_main_frame
+                                          false,    // parent_is_main_frame
+                                          true,     // allow_download
+                                          true,     // is_async
+                                          false);   // is_using_lofi
+
+  std::unique_ptr<ResourceHandler> old_handler(new TestResourceHandler());
+  scoped_refptr<net::IOBuffer> old_buffer =
+      static_cast<TestResourceHandler*>(old_handler.get())->buffer();
+  std::unique_ptr<ResourceHandler> handler(
+      new InterceptingResourceHandler(std::move(old_handler), request.get()));
+  InterceptingResourceHandler* intercepting_handler =
+      static_cast<InterceptingResourceHandler*>(handler.get());
+
+  scoped_refptr<ResourceResponse> response(new ResourceResponse);
+
+  // Simulate the MimeSniffingResourceHandler buffering the data.
+  scoped_refptr<net::IOBuffer> read_buffer;
+  int buf_size = 0;
+  handler->OnWillRead(&read_buffer, &buf_size, -1);
+
+  char data[] = "The data";

[mmenke, 2016/07/19 21:42:33]

const char kData

[clamy, 2016/07/25 16:58:25]

Done.

+  CHECK_EQ(read_buffer.get(), old_buffer.get());
+  memcpy(read_buffer->data(), data, sizeof(data));
+
+  // Simulate the MimeSniffingResourceHandler asking the
+  // InterceptingResourceHandler to switch to a new handler.
+  std::unique_ptr<ResourceHandler> new_handler(new TestResourceHandler());
+  TestResourceHandler* new_test_handler =
+      static_cast<TestResourceHandler*>(new_handler.get());
+  intercepting_handler->UseNewHandler(std::move(new_handler), std::string());

[mmenke, 2016/07/19 21:42:33]

Should check that the old handler gets the abort message.

Should also add a test where |payload_for_old_handler_| is non-empty, and make
sure the old handler gets the data and the success status.

[clamy, 2016/07/25 16:58:25]

Done.

+
+  // The response is received. The new ResourceHandler should be used handle
+  // the download.
+  bool defer = false;
+  handler->OnResponseStarted(response.get(), &defer);
+  EXPECT_FALSE(defer);
+
+  // It should not have received the download data yet.
+  EXPECT_FALSE(!memcmp(data, new_test_handler->buffer()->data(), sizeof(data)));

[mmenke, 2016/07/19 21:42:33]

Have we put any data in new_test_handler->buffer()->data() yet?  I don't see us
populating it with \0's anywhere, though I could be missing something.

[clamy, 2016/07/25 16:58:26]

Done. The buffer is now populated with 0s at creation.

+
+  // The read is replayed by the MimeSniffingResourceHandler. The data should
+  // have been received by the new handler.
+  handler->OnReadCompleted(sizeof(data), &defer);
+  EXPECT_FALSE(defer);
+  EXPECT_TRUE(!memcmp(data, new_test_handler->buffer()->data(), sizeof(data)));

[mmenke, 2016/07/19 21:42:33]

Seems like we should check a second read, make sure things behave as expected.

[clamy, 2016/07/25 16:58:26]

Done.

+}
+
+}  // namespace
+
+}  // namespace content