Store, use and send etags.

media/blink/resource_multibuffer_data_provider_unittest.cc

 // Copyright 2015 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 "media/blink/resource_multibuffer_data_provider.h"
 
 #include <stdint.h>
 #include <algorithm>
 #include <string>
 #include <utility>
@@ skipping 28 matching lines @@
 using blink::WebLocalFrame;
 using blink::WebString;
 using blink::WebURLError;
 using blink::WebURLResponse;
 using blink::WebView;
 
 namespace media {
 
 const char kHttpUrl[] = "http://test";
 const char kHttpRedirect[] = "http://test/ing";
+const char kEtag[] = "\"arglebargle glopy-glyf?\"";
 
 const int kDataSize = 1024;
 const int kHttpOK = 200;
 const int kHttpPartialContent = 206;
 
 enum NetworkState { NONE, LOADED, LOADING };
 
 // Predicate that tests that request disallows compressed data.
-static bool CorrectAcceptEncoding(const blink::WebURLRequest& request) {
+static bool CorrectAcceptEncodingAndEtag(const blink::WebURLRequest& request) {
+  std::string etag =
+      request.httpHeaderField(WebString::fromUTF8("If-Match")).utf8();
+  EXPECT_EQ(etag, kEtag);
+
   std::string value =
       request.httpHeaderField(
                  WebString::fromUTF8(net::HttpRequestHeaders::kAcceptEncoding))
           .utf8();
   return (value.find("identity;q=1") != std::string::npos) &&
          (value.find("*;q=0") != std::string::npos);
 }
 
 class ResourceMultiBufferDataProviderTest : public testing::Test {
  public:
@@ skipping 10 matching lines @@
   }
 
   virtual ~ResourceMultiBufferDataProviderTest() {
     view_->close();
     frame_->close();
   }
 
   void Initialize(const char* url, int first_position) {
     gurl_ = GURL(url);
     url_data_ = url_index_->GetByUrl(gurl_, UrlData::CORS_UNSPECIFIED);
+    url_data_->set_etag(kEtag);
     DCHECK(url_data_);
     DCHECK(url_data_->frame());
     url_data_->OnRedirect(
         base::Bind(&ResourceMultiBufferDataProviderTest::RedirectCallback,
                    base::Unretained(this)));
 
     first_position_ = first_position;
 
     std::unique_ptr<ResourceMultiBufferDataProvider> loader(
         new ResourceMultiBufferDataProvider(url_data_.get(), first_position_));
     loader_ = loader.get();
     url_data_->multibuffer()->AddProvider(std::move(loader));
 
     // |test_loader_| will be used when Start() is called.
     url_loader_ = new NiceMock<MockWebURLLoader>();
     loader_->test_loader_ = std::unique_ptr<blink::WebURLLoader>(url_loader_);
   }
 
   void Start() {
     InSequence s;
-    EXPECT_CALL(*url_loader_,
-                loadAsynchronously(Truly(CorrectAcceptEncoding), loader_));
+    EXPECT_CALL(
+        *url_loader_,
+        loadAsynchronously(Truly(CorrectAcceptEncodingAndEtag), loader_));
 
     loader_->Start();
   }
 
   void FullResponse(int64_t instance_size, bool ok = true) {
     WebURLResponse response(gurl_);
     response.setHTTPHeaderField(
         WebString::fromUTF8("Content-Length"),
         WebString::fromUTF8(base::StringPrintf("%" PRId64, instance_size)));
     response.setExpectedContentLength(instance_size);
@@ skipping 204 matching lines @@
 TEST_F(ResourceMultiBufferDataProviderTest, TestRedirects) {
   // Test redirect.
   Initialize(kHttpUrl, 0);
   Start();
   Redirect(kHttpRedirect);
   FullResponse(1024);
   StopWhenLoad();
 }
 
 }  // namespace media