Implement prefetching in chrome

net/spdy/spdy_network_transaction_unittest.cc

 // Copyright (c) 2010 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 "net/base/net_log_unittest.h"
 #include "net/http/http_transaction_unittest.h"
 #include "net/spdy/spdy_http_stream.h"
 #include "net/spdy/spdy_network_transaction.h"
 #include "net/spdy/spdy_test_util.h"
 #include "testing/platform_test.h"
@@ skipping 271 matching lines @@
                             writes, arraysize(writes)));
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.RunToCompletion(data.get());
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 }
 
+TEST_P(SpdyNetworkTransactionTest, GetAtEachPriority) {
+  for (RequestPriority p = HIGHEST; p < NUM_PRIORITIES;
+       p = RequestPriority(p+1)) {
+    // Construct the request.
+    scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, p));
+    MockWrite writes[] = { CreateMockWrite(*req) };
+
+    const int spdy_prio = reinterpret_cast<spdy::SpdySynStreamControlFrame*>(
+        req.get())->priority();
+    // this repeats the RequestPriority-->SpdyPriority mapping from
+    // SpdyFramer::ConvertRequestPriorityToSpdyPriority to make
+    // sure it's being done right.
+    switch(p) {
+      case HIGHEST:
+        EXPECT_EQ(0, spdy_prio);
+        break;
+      case MEDIUM:
+        EXPECT_EQ(1, spdy_prio);
+        break;
+      case LOW:
+      case LOWEST:
+        EXPECT_EQ(2, spdy_prio);
+        break;
+      case IDLE:
+        EXPECT_EQ(3, spdy_prio);
+        break;
+      default:
+        FAIL();
+    }
+
+    scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
+    scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
+    MockRead reads[] = {
+      CreateMockRead(*resp),
+      CreateMockRead(*body),
+      MockRead(true, 0, 0)  // EOF
+    };
+
+    scoped_refptr<DelayedSocketData> data(
+        new DelayedSocketData(1, reads, arraysize(reads),
+                              writes, arraysize(writes)));
+    HttpRequestInfo http_req = CreateGetRequest();
+    http_req.priority = p;
+
+    NormalSpdyTransactionHelper helper(http_req, BoundNetLog(), GetParam());
+    helper.RunToCompletion(data.get());
+    TransactionHelperResult out = helper.output();
+    EXPECT_EQ(OK, out.rv);
+    EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
+    EXPECT_EQ("hello!", out.response_data);
+  }
+}
+
 // Start three gets simultaniously; making sure that multiplexed
 // streams work properly.
 
 // This can't use the TransactionHelper method, since it only
 // handles a single transaction, and finishes them as soon
 // as it launches them.
 
 // TODO(gavinp): create a working generalized TransactionHelper that
 // can allow multiple streams in flight.
 
@@ skipping 1104 matching lines @@
   }
 }
 
 // Verify that various SynReply headers parse vary fields correctly
 // through the HTTP layer, and the response matches the request.
 TEST_P(SpdyNetworkTransactionTest, SynReplyHeadersVary) {
   static const SpdyHeaderInfo syn_reply_info = {
     spdy::SYN_REPLY,                              // Syn Reply
     1,                                            // Stream ID
     0,                                            // Associated Stream ID
-    SPDY_PRIORITY_LOWEST,                         // Priority
+    net::ConvertRequestPriorityToSpdyPriority(LOWEST),
+                                                  // Priority
     spdy::CONTROL_FLAG_NONE,                      // Control Flags
     false,                                        // Compressed
     spdy::INVALID,                                // Status
     NULL,                                         // Data
     0,                                            // Data Length
     spdy::DATA_FLAG_NONE                          // Data Flags
   };
   // Modify the following data to change/add test cases:
   struct SynReplyTests {
     const SpdyHeaderInfo* syn_reply;
@@ skipping 147 matching lines @@
     EXPECT_EQ(std::string(reply_buffer), lines) << i;
   }
 }
 
 // Verify that we don't crash on invalid SynReply responses.
 TEST_P(SpdyNetworkTransactionTest, InvalidSynReply) {
   const SpdyHeaderInfo kSynStartHeader = {
     spdy::SYN_REPLY,              // Kind = SynReply
     1,                            // Stream ID
     0,                            // Associated stream ID
-    SPDY_PRIORITY_LOWEST,         // Priority
+    net::ConvertRequestPriorityToSpdyPriority(LOWEST),
+                                  // Priority
     spdy::CONTROL_FLAG_NONE,      // Control Flags
     false,                        // Compressed
     spdy::INVALID,                // Status
     NULL,                         // Data
     0,                            // Length
     spdy::DATA_FLAG_NONE          // Data Flags
   };
 
   struct InvalidSynReplyTests {
     int num_headers;
@@ skipping 740 matching lines @@
   helper.VerifyDataConsumed();
 }
 
 // Test that if the server requests persistence of settings, that we save
 // the settings in the SpdySettingsStorage.
 TEST_P(SpdyNetworkTransactionTest, SettingsSaved) {
   static const SpdyHeaderInfo kSynReplyInfo = {
     spdy::SYN_REPLY,                              // Syn Reply
     1,                                            // Stream ID
     0,                                            // Associated Stream ID
-    SPDY_PRIORITY_LOWEST,                         // Priority
+    net::ConvertRequestPriorityToSpdyPriority(LOWEST),
+                                                  // Priority
     spdy::CONTROL_FLAG_NONE,                      // Control Flags
     false,                                        // Compressed
     spdy::INVALID,                                // Status
     NULL,                                         // Data
     0,                                            // Data Length
     spdy::DATA_FLAG_NONE                          // Data Flags
   };
   static const char* const kExtraHeaders[] = {
     "status",   "200",
     "version",  "HTTP/1.1"
@@ skipping 83 matching lines @@
   }
 }
 
 // Test that when there are settings saved that they are sent back to the
 // server upon session establishment.
 TEST_P(SpdyNetworkTransactionTest, SettingsPlayback) {
   static const SpdyHeaderInfo kSynReplyInfo = {
     spdy::SYN_REPLY,                              // Syn Reply
     1,                                            // Stream ID
     0,                                            // Associated Stream ID
-    SPDY_PRIORITY_LOWEST,                         // Priority
+    net::ConvertRequestPriorityToSpdyPriority(LOWEST),
+                                                  // Priority
     spdy::CONTROL_FLAG_NONE,                      // Control Flags
     false,                                        // Compressed
     spdy::INVALID,                                // Status
     NULL,                                         // Data
     0,                                            // Data Length
     spdy::DATA_FLAG_NONE                          // Data Flags
   };
   static const char* kExtraHeaders[] = {
     "status",   "200",
     "version",  "HTTP/1.1"
@@ skipping 138 matching lines @@
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_TRUE(response->headers != NULL);
   EXPECT_TRUE(response->was_fetched_via_spdy);
   out.rv = ReadTransaction(trans, &out.response_data);
   EXPECT_EQ(ERR_CONNECTION_CLOSED, out.rv);
 
   // Verify that we consumed all test data.
   helper.VerifyDataConsumed();
 }
 }  // namespace net