Move MimeTypeResourceHandler before ThrottlingResourceHandler

content/browser/loader/intercepting_resource_handler.h

+// 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.
+
+#ifndef CONTENT_BROWSER_LOADER_INTERCEPTING_RESOURCE_HANDLER_H_
+#define CONTENT_BROWSER_LOADER_INTERCEPTING_RESOURCE_HANDLER_H_
+
+#include <memory>
+#include <string>
+
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/weak_ptr.h"
+#include "content/browser/loader/layered_resource_handler.h"
+#include "content/common/content_export.h"
+#include "net/base/io_buffer.h"
+
+namespace net {
+class URLRequest;
+}
+
+namespace content {
+
+// ResourceHandler that initiates special handling of the response if needed,
+// based on the response's MIME type (starts downloads, sends data to some
+// plugin types via a special channel).
+class CONTENT_EXPORT InterceptingResourceHandler
+    : public LayeredResourceHandler {
+ public:
+  // If ENABLE_PLUGINS is defined, |plugin_service| must not be NULL.
+  InterceptingResourceHandler(std::unique_ptr<ResourceHandler> next_handler,
+                              net::URLRequest* request);
+  ~InterceptingResourceHandler() override;
+
+  void UseNewHandler(std::unique_ptr<ResourceHandler> new_handler,
+                     const std::string& payload_for_old_handler);
+
+ private:
+  enum class State {
+    // In this state, the InterceptingResourceHandler is waiting for the mime
+    // type of the response to be identified, to check if the next handler
+    // should be replaced with an appropriate one.
+    STARTING,
+
+    // In this state, the InterceptingResourceHandler is waiting to copy the
+    // read buffer to the next handler if it was replaced. This is needed
+    // because MimeTypeResourceHandler may call OnWillRead before calling
+    // OnResponseStarted, that is before the InterceptingResourceHandler
+    // replaces the original ResourceHandler of the request. Therefore, the
+    // data read at that time should be copied to the new ResourceHandler.
+    WAITING_FOR_BUFFER_COPY,
+
+    // In this state, the InterceptingResourceHandler has replaced its next
+    // ResourceHandler if needed, and has ensured the buffered read data was
+    // properly transmitted to the new ResourceHandler. The
+    // InterceptingResourceHandler now acts as a pass-through ResourceHandler.
+    DONE,
+  };
+
+  // ResourceHandler implementation:
+  bool OnResponseStarted(ResourceResponse* response, bool* defer) override;
+  bool OnWillRead(scoped_refptr<net::IOBuffer>* buf,
+                  int* buf_size,
+                  int min_size) override;
+  bool OnReadCompleted(int bytes_read, bool* defer) override;
+
+  void SendPayloadToOldHandler();
+
+  State state_;
+
+  std::unique_ptr<ResourceHandler> new_handler_;
+  std::string payload_for_old_handler_;
+
+  // Used to copy data to the new next ResourceHandler.
+  scoped_refptr<net::IOBuffer> read_buffer_;

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

Maybe call this first_read_buffer_, and mention that it's only the results of
the first read (from this class's perspective) that may have to be passed to an
alternate ResourceHandler instead of the original handler?

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

Done.

+
+  DISALLOW_COPY_AND_ASSIGN(InterceptingResourceHandler);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_LOADER_INTERCEPTING_RESOURCE_HANDLER_H_