Network traffic annotation added to appcache_update_job.

content/browser/appcache/appcache_url_request_job_unittest.cc

 // Copyright 2014 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/appcache/appcache_url_request_job.h"
 
 #include <stdint.h>
 #include <string.h>
 
 #include <memory>
@@ skipping 13 matching lines @@
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/browser/appcache/appcache_response.h"
 #include "content/browser/appcache/mock_appcache_service.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/request_priority.h"
 #include "net/http/http_response_headers.h"
+#include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_error_job.h"
 #include "net/url_request/url_request_job_factory.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 using net::IOBuffer;
 using net::WrappedIOBuffer;
 
@@ skipping 409 matching lines @@
   }
 
   // Individual Tests ---------------------------------------------------------
   // Some of the individual tests involve multiple async steps. Each test
   // is delineated with a section header.
 
   // Basic -------------------------------------------------------------------
   void Basic() {
     AppCacheStorage* storage = service_->storage();
     request_ = empty_context_->CreateRequest(GURL("http://blah/"),
-                                             net::DEFAULT_PRIORITY, nullptr);
+                                             net::DEFAULT_PRIORITY, nullptr,
+                                             TRAFFIC_ANNOTATION_FOR_TESTS);
 
     // Create an instance and see that it looks as expected.
 
     std::unique_ptr<AppCacheURLRequestJob> job(
         new AppCacheURLRequestJob(request_.get(), nullptr, storage, nullptr,
                                   false, base::Bind(&ExpectNotRestarted)));
     EXPECT_TRUE(job->IsWaiting());
     EXPECT_FALSE(job->IsDeliveringAppCacheResponse());
     EXPECT_FALSE(job->IsDeliveringNetworkResponse());
     EXPECT_FALSE(job->IsDeliveringErrorResponse());
     EXPECT_FALSE(job->IsStarted());
     EXPECT_FALSE(job->has_been_killed());
     EXPECT_EQ(GURL(), job->manifest_url());
     EXPECT_EQ(kAppCacheNoCacheId, job->cache_id());
     EXPECT_FALSE(job->entry().has_response_id());
 
     TestFinished();
   }
 
   // DeliveryOrders -----------------------------------------------------
   void DeliveryOrders() {
     AppCacheStorage* storage = service_->storage();
     std::unique_ptr<net::URLRequest> request(empty_context_->CreateRequest(
-        GURL("http://blah/"), net::DEFAULT_PRIORITY, nullptr));
+        GURL("http://blah/"), net::DEFAULT_PRIORITY, nullptr,
+        TRAFFIC_ANNOTATION_FOR_TESTS));
 
     // Create an instance, give it a delivery order and see that
     // it looks as expected.
 
     std::unique_ptr<AppCacheURLRequestJob> job(
         new AppCacheURLRequestJob(request.get(), nullptr, storage, nullptr,
                                   false, base::Bind(&ExpectNotRestarted)));
     job->DeliverErrorResponse();
     EXPECT_TRUE(job->IsDeliveringErrorResponse());
     EXPECT_FALSE(job->IsStarted());
@@ skipping 25 matching lines @@
 
   // DeliverNetworkResponse --------------------------------------------------
 
   void DeliverNetworkResponse() {
     // This test has async steps.
     PushNextTask(
         base::Bind(&AppCacheURLRequestJobTest::VerifyDeliverNetworkResponse,
                    base::Unretained(this)));
 
     AppCacheStorage* storage = service_->storage();
-    request_ = empty_context_->CreateRequest(GURL("http://blah/"),
-                                             net::DEFAULT_PRIORITY,
-                                             url_request_delegate_.get());
+    request_ = empty_context_->CreateRequest(
+        GURL("http://blah/"), net::DEFAULT_PRIORITY,
+        url_request_delegate_.get(), TRAFFIC_ANNOTATION_FOR_TESTS);
 
     // Set up to create an AppCacheURLRequestJob with orders to deliver
     // a network response.
     std::unique_ptr<AppCacheURLRequestJob> mock_job(new AppCacheURLRequestJob(
         request_.get(), nullptr, storage, nullptr, false,
         base::Bind(&SetIfCalled, &restart_callback_invoked_)));
     mock_job->DeliverNetworkResponse();
     EXPECT_TRUE(mock_job->IsDeliveringNetworkResponse());
     EXPECT_FALSE(mock_job->IsStarted());
     job_factory_->SetJob(std::move(mock_job));
@@ skipping 15 matching lines @@
 
   // DeliverErrorResponse --------------------------------------------------
 
   void DeliverErrorResponse() {
     // This test has async steps.
     PushNextTask(
         base::Bind(&AppCacheURLRequestJobTest::VerifyDeliverErrorResponse,
                    base::Unretained(this)));
 
     AppCacheStorage* storage = service_->storage();
-    request_ = empty_context_->CreateRequest(GURL("http://blah/"),
-                                             net::DEFAULT_PRIORITY,
-                                             url_request_delegate_.get());
+    request_ = empty_context_->CreateRequest(
+        GURL("http://blah/"), net::DEFAULT_PRIORITY,
+        url_request_delegate_.get(), TRAFFIC_ANNOTATION_FOR_TESTS);
 
     // Setup to create an AppCacheURLRequestJob with orders to deliver
     // a network response.
     std::unique_ptr<AppCacheURLRequestJob> mock_job(
         new AppCacheURLRequestJob(request_.get(), nullptr, storage, nullptr,
                                   false, base::Bind(&ExpectNotRestarted)));
     mock_job->DeliverErrorResponse();
     EXPECT_TRUE(mock_job->IsDeliveringErrorResponse());
     EXPECT_FALSE(mock_job->IsStarted());
     job_factory_->SetJob(std::move(mock_job));
@@ skipping 29 matching lines @@
                    base::Unretained(this), false));
 
     writer_.reset(service_->storage()->CreateResponseWriter(GURL()));
     written_response_id_ = writer_->response_id();
     WriteBasicResponse();
     // Continues async
   }
 
   void RequestAppCachedResource(bool start_after_delivery_orders) {
     AppCacheStorage* storage = service_->storage();
-    request_ = empty_context_->CreateRequest(GURL("http://blah/"),
-                                             net::DEFAULT_PRIORITY,
-                                             url_request_delegate_.get());
+    request_ = empty_context_->CreateRequest(
+        GURL("http://blah/"), net::DEFAULT_PRIORITY,
+        url_request_delegate_.get(), TRAFFIC_ANNOTATION_FOR_TESTS);
 
     // Setup to create an AppCacheURLRequestJob with orders to deliver
     // a network response.
     std::unique_ptr<AppCacheURLRequestJob> job(
         new AppCacheURLRequestJob(request_.get(), NULL, storage, NULL, false,
                                   base::Bind(&ExpectNotRestarted)));
 
     if (start_after_delivery_orders) {
       job->DeliverAppCachedResponse(
           GURL(), 111,
@@ skipping 93 matching lines @@
     PushNextTask(base::Bind(
        &AppCacheURLRequestJobTest::MakeRangeRequest, base::Unretained(this)));
     writer_.reset(service_->storage()->CreateResponseWriter(GURL()));
     written_response_id_ = writer_->response_id();
     WriteBasicResponse();
     // Continues async
   }
 
   void MakeRangeRequest() {
     AppCacheStorage* storage = service_->storage();
-    request_ = empty_context_->CreateRequest(GURL("http://blah/"),
-                                             net::DEFAULT_PRIORITY,
-                                             url_request_delegate_.get());
+    request_ = empty_context_->CreateRequest(
+        GURL("http://blah/"), net::DEFAULT_PRIORITY,
+        url_request_delegate_.get(), TRAFFIC_ANNOTATION_FOR_TESTS);
 
     // Request a range, the 3 middle chars out of 'Hello'
     net::HttpRequestHeaders extra_headers;
     extra_headers.SetHeader("Range", "bytes= 1-3");
     request_->SetExtraRequestHeaders(extra_headers);
 
     // Create job with orders to deliver an appcached entry.
     std::unique_ptr<AppCacheURLRequestJob> job(
         new AppCacheURLRequestJob(request_.get(), NULL, storage, NULL, false,
                                   base::Bind(&ExpectNotRestarted)));
@@ skipping 144 matching lines @@
 
 TEST_F(AppCacheURLRequestJobTest, CancelRequest) {
   RunTestOnIOThread(&AppCacheURLRequestJobTest::CancelRequest);
 }
 
 TEST_F(AppCacheURLRequestJobTest, CancelRequestWithIOPending) {
   RunTestOnIOThread(&AppCacheURLRequestJobTest::CancelRequestWithIOPending);
 }
 
 }  // namespace content