Test network traffic annotation tag added to fileapi unittests.

storage/browser/fileapi/file_writer_delegate_unittest.cc

 // 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.
 
 #include <stdint.h>
 #include <limits>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "net/base/io_buffer.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_job.h"
 #include "net/url_request/url_request_job_factory.h"
 #include "net/url_request/url_request_status.h"
 #include "storage/browser/fileapi/file_system_context.h"
 #include "storage/browser/fileapi/file_system_quota_util.h"
 #include "storage/browser/fileapi/file_writer_delegate.h"
 #include "storage/browser/fileapi/sandbox_file_stream_writer.h"
 #include "storage/browser/test/async_file_test_helper.h"
@@ skipping 108 matching lines @@
   }
 
   // Creates and sets up a FileWriterDelegate for writing the given |blob_url|,
   // and creates a new FileWriterDelegate for the file.
   void PrepareForWrite(const char* test_file_path,
                        const GURL& blob_url,
                        int64_t offset,
                        int64_t allowed_growth) {
     file_writer_delegate_.reset(
         CreateWriterDelegate(test_file_path, offset, allowed_growth));
-    request_ = empty_context_.CreateRequest(
-        blob_url, net::DEFAULT_PRIORITY, file_writer_delegate_.get());
+    request_ = empty_context_.CreateRequest(blob_url, net::DEFAULT_PRIORITY,
+                                            file_writer_delegate_.get(),
+                                            TRAFFIC_ANNOTATION_FOR_TESTS);
   }
 
   // This should be alive until the very end of this instance.
   base::MessageLoopForIO loop_;
 
   scoped_refptr<storage::FileSystemContext> file_system_context_;
 
   net::URLRequestContext empty_context_;
   std::unique_ptr<FileWriterDelegate> file_writer_delegate_;
   std::unique_ptr<net::URLRequest> request_;
@@ skipping 209 matching lines @@
 
   const GURL kBlobURL("blob:nolimitconcurrent");
   const GURL kBlobURL2("blob:nolimitconcurrent2");
   content_ = kData;
 
   PrepareForWrite("test", kBlobURL, 0, std::numeric_limits<int64_t>::max());
 
   // Credate another FileWriterDelegate for concurrent write.
   file_writer_delegate2.reset(
       CreateWriterDelegate("test2", 0, std::numeric_limits<int64_t>::max()));
-  request2 = empty_context_.CreateRequest(
-      kBlobURL2, net::DEFAULT_PRIORITY, file_writer_delegate2.get());
+  request2 = empty_context_.CreateRequest(kBlobURL2, net::DEFAULT_PRIORITY,
+                                          file_writer_delegate2.get(),
+                                          TRAFFIC_ANNOTATION_FOR_TESTS);
 
   Result result, result2;
   ASSERT_EQ(0, usage());
   file_writer_delegate_->Start(std::move(request_), GetWriteCallback(&result));
   file_writer_delegate2->Start(std::move(request2), GetWriteCallback(&result2));
   base::RunLoop().Run();
   if (result.write_status() == FileWriterDelegate::SUCCESS_IO_PENDING ||
       result2.write_status() == FileWriterDelegate::SUCCESS_IO_PENDING)
     base::RunLoop().Run();
 
@@ skipping 109 matching lines @@
     file_writer_delegate_.reset();
 
     EXPECT_EQ(pre_write_usage + allowed_growth, usage());
     EXPECT_EQ(GetFileSizeOnDisk("test"), usage());
     EXPECT_EQ(kOverlap + allowed_growth, result.bytes_written());
     EXPECT_EQ(base::File::FILE_ERROR_NO_SPACE, result.status());
   }
 }
 
 }  // namespace content