Introduce WebSocketDeflatePredictor.

net/websockets/websocket_deflate_predictor.h

Index: net/websockets/websocket_deflate_predictor.h
diff --git a/net/websockets/websocket_deflate_predictor.h b/net/websockets/websocket_deflate_predictor.h
new file mode 100644
index 0000000000000000000000000000000000000000..14660a8a674886c6728eb5e23229e6cb07b65e1f
--- /dev/null
+++ b/net/websockets/websocket_deflate_predictor.h
@@ -0,0 +1,57 @@
+// Copyright 2013 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 NET_WEBSOCKETS_WEBSOCKET_DEFLATE_PREDICTOR_H_
+#define NET_WEBSOCKETS_WEBSOCKET_DEFLATE_PREDICTOR_H_
+
+#include "base/basictypes.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/memory/scoped_vector.h"
+#include "net/base/net_export.h"
+
+namespace net {
+
+struct WebSocketFrame;
+
+// WebSocketDeflatePredictor is an interface class used for judging whether
+// a WebSocketDeflateStream should compress a message or not.
+class NET_EXPORT_PRIVATE WebSocketDeflatePredictor {
+ public:
+  enum Result {
+    // Deflate and send the message.
+    DEFLATE,
+    // Do not deflate and send the original message.
+    DO_NOT_DEFLATE,
+    // Try compressing the message and send the smaller one of the original
+    // and the compressed message.
+    // Returning this result implies that the deflater is running on
+    // DoNotTakeOverContext mode and the entire message is visible.
+    TRY_DEFLATE,
+  };
+
+  virtual ~WebSocketDeflatePredictor() {}
+
+  // Predicts and returns whether the deflater should deflate the message
+  // which begins with |frames[frame_index]| or not.
+  // |frames[(frame_index + 1):]| consists of future frames if any.
+  // |frames[frame_index]| must be the first frame of a data message,
+  // but future frames may contain control message frames.
+  virtual Result Predict(const ScopedVector<WebSocketFrame>& frames,
+                         size_t frame_index) = 0;
+
+  // Records frame data for future prediction.
+  // Only data frames should be recorded. Do not pass control frames' data.
+  // All input data frames must be recorded in order.
+  virtual void RecordProcessedDataFrame(const WebSocketFrame* frame) = 0;

[Adam Rice, 2013/10/29 04:11:42]

I assume this should be called after Predict(), so that for each data frame the
caller will run

Predict()
RecordProcessedDataFrame()
RecordSentDataFrame()

in that order.

I'm not sure what "Processed" means in the name of this method. I would expect
it to be "Raw", ie. before applying any compression or other transformations.

[yhirano, 2013/10/29 06:11:06]

Predict will be called only for the first frame of each data message.
s/Processed/Input/g

[Adam Rice, 2013/10/30 00:28:07]

Is it okay to call this method before Predict() for the same frame? If not, I
think the comment should say so.

[yhirano, 2013/10/30 02:20:33]

I added |Predict| comment.

+
+  // Records frame data for future prediction.
+  // Only data frames should be recorded. Do not pass control frames' data.
+  // All sent data frames must be recorded in order regardless of whether
+  // they are compressed or not.
+  virtual void RecordSentDataFrame(const WebSocketFrame* frame) = 0;

[Adam Rice, 2013/10/29 04:11:42]

It's ambiguous whether this is supposed to be called for the final frame that is
sent over the TCP/IP connection (including any other extensions applied like
multiplexing), or only for the output of the deflate extension.

[yhirano, 2013/10/29 06:11:06]

s/Sent/Written/g
and
add "by the stream"

+};
+
+}  // namespace net
+
+#endif  // NET_WEBSOCKETS_WEBSOCKET_DEFLATE_PREDICTOR_H_