Convert //chrome/browser/extensions from scoped_ptr to std::unique_ptr

chrome/browser/extensions/api/web_request/web_request_api_unittest.cc

 // Copyright (c) 2012 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 <stddef.h>
 #include <stdint.h>
 
 #include <map>
+#include <memory>
 #include <queue>
 #include <tuple>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/location.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "chrome/browser/content_settings/cookie_settings_factory.h"
@@ skipping 180 matching lines @@
                               const std::vector<char>& bytes_2);
 
   content::TestBrowserThreadBundle thread_bundle_;
   TestingProfile profile_;
   TestingProfileManager profile_manager_;
   net::TestDelegate delegate_;
   BooleanPrefMember enable_referrers_;
   TestIPCSender ipc_sender_;
   scoped_refptr<EventRouterForwarder> event_router_;
   scoped_refptr<InfoMap> extension_info_map_;
-  scoped_ptr<ChromeNetworkDelegate> network_delegate_;
-  scoped_ptr<net::TestURLRequestContext> context_;
+  std::unique_ptr<ChromeNetworkDelegate> network_delegate_;
+  std::unique_ptr<net::TestURLRequestContext> context_;
 };
 
 // Tests that we handle disagreements among extensions about responses to
 // blocking events (redirection) by choosing the response from the
 // most-recently-installed extension.
 TEST_F(ExtensionWebRequestTest, BlockingEventPrecedenceRedirect) {
   std::string extension1_id("1");
   std::string extension2_id("2");
   ExtensionWebRequestEventRouter::RequestFilter filter;
   const std::string kEventName(web_request::OnBeforeRequest::kEventName);
   base::WeakPtrFactory<TestIPCSender> ipc_sender_factory(&ipc_sender_);
   ExtensionWebRequestEventRouter::GetInstance()->AddEventListener(
       &profile_, extension1_id, extension1_id, events::FOR_TEST, kEventName,
       kEventName + "/1", filter, ExtraInfoSpec::BLOCKING, 0, 0,
       ipc_sender_factory.GetWeakPtr());
   ExtensionWebRequestEventRouter::GetInstance()->AddEventListener(
       &profile_, extension2_id, extension2_id, events::FOR_TEST, kEventName,
       kEventName + "/2", filter, ExtraInfoSpec::BLOCKING, 0, 0,
       ipc_sender_factory.GetWeakPtr());
 
   net::URLRequestJobFactoryImpl job_factory;
   job_factory.SetProtocolHandler(
       url::kAboutScheme,
-      make_scoped_ptr(new about_handler::AboutProtocolHandler()));
+      base::WrapUnique(new about_handler::AboutProtocolHandler()));
   context_->set_job_factory(&job_factory);
 
   GURL redirect_url("about:redirected");
   GURL not_chosen_redirect_url("about:not_chosen");
 
-  scoped_ptr<net::URLRequest> request(context_->CreateRequest(
+  std::unique_ptr<net::URLRequest> request(context_->CreateRequest(
       GURL("about:blank"), net::DEFAULT_PRIORITY, &delegate_));
   {
     // onBeforeRequest will be dispatched twice initially. The second response -
     // the redirect - should win, since it has a later |install_time|. The
     // redirect will dispatch another pair of onBeforeRequest. There, the first
     // response should win (later |install_time|).
     ExtensionWebRequestEventRouter::EventResponse* response = NULL;
 
     // Extension1 response. Arrives first, but ignored due to install_time.
     response = new ExtensionWebRequestEventRouter::EventResponse(
@@ skipping 34 matching lines @@
 
     EXPECT_TRUE(!request->is_pending());
     EXPECT_EQ(net::URLRequestStatus::SUCCESS, request->status().status());
     EXPECT_EQ(0, request->status().error());
     EXPECT_EQ(redirect_url, request->url());
     EXPECT_EQ(2U, request->url_chain().size());
     EXPECT_EQ(0U, ipc_sender_.GetNumTasks());
   }
 
   // Now test the same thing but the extensions answer in reverse order.
-  scoped_ptr<net::URLRequest> request2(context_->CreateRequest(
+  std::unique_ptr<net::URLRequest> request2(context_->CreateRequest(
       GURL("about:blank"), net::DEFAULT_PRIORITY, &delegate_));
   {
     ExtensionWebRequestEventRouter::EventResponse* response = NULL;
 
     // Extension2 response. Arrives first, and chosen because of install_time.
     response = new ExtensionWebRequestEventRouter::EventResponse(
         extension2_id, base::Time::FromDoubleT(2));
     response->new_url = redirect_url;
     ipc_sender_.PushTask(
         base::Bind(&EventHandledOnIOThread,
@@ skipping 53 matching lines @@
   ExtensionWebRequestEventRouter::GetInstance()->AddEventListener(
       &profile_, extension1_id, extension1_id, events::FOR_TEST, kEventName,
       kEventName + "/1", filter, ExtraInfoSpec::BLOCKING, 0, 0,
       ipc_sender_factory.GetWeakPtr());
   ExtensionWebRequestEventRouter::GetInstance()->AddEventListener(
       &profile_, extension2_id, extension2_id, events::FOR_TEST, kEventName,
       kEventName + "/2", filter, ExtraInfoSpec::BLOCKING, 0, 0,
       ipc_sender_factory.GetWeakPtr());
 
   GURL request_url("about:blank");
-  scoped_ptr<net::URLRequest> request(context_->CreateRequest(
-      request_url, net::DEFAULT_PRIORITY, &delegate_));
+  std::unique_ptr<net::URLRequest> request(
+      context_->CreateRequest(request_url, net::DEFAULT_PRIORITY, &delegate_));
 
   // onBeforeRequest will be dispatched twice. The second response -
   // the redirect - would win, since it has a later |install_time|, but
   // the first response takes precedence because cancel >> redirect.
   GURL redirect_url("about:redirected");
   ExtensionWebRequestEventRouter::EventResponse* response = NULL;
 
   // Extension1 response. Arrives first, would be ignored in principle due to
   // install_time but "cancel" always wins.
   response = new ExtensionWebRequestEventRouter::EventResponse(
@@ skipping 46 matching lines @@
   base::WeakPtrFactory<TestIPCSender> ipc_sender_factory(&ipc_sender_);
   ExtensionWebRequestEventRouter::GetInstance()->AddEventListener(
       &profile_, extension_id, extension_id, events::FOR_TEST, kEventName,
       kEventName + "/1", filter, ExtraInfoSpec::BLOCKING, 0, 0,
       ipc_sender_factory.GetWeakPtr());
   ExtensionWebRequestEventRouter::GetInstance()->AddEventListener(
       &profile_, extension_id, extension_id, events::FOR_TEST, kEventName2,
       kEventName2 + "/1", filter, 0, 0, 0, ipc_sender_factory.GetWeakPtr());
 
   GURL request_url("about:blank");
-  scoped_ptr<net::URLRequest> request(context_->CreateRequest(
-      request_url, net::DEFAULT_PRIORITY, &delegate_));
+  std::unique_ptr<net::URLRequest> request(
+      context_->CreateRequest(request_url, net::DEFAULT_PRIORITY, &delegate_));
 
   ExtensionWebRequestEventRouter::EventResponse* response = NULL;
 
   // Extension response for the OnBeforeRequest handler. This should not be
   // processed because request is canceled before the handler responds.
   response = new ExtensionWebRequestEventRouter::EventResponse(
       extension_id, base::Time::FromDoubleT(1));
   GURL redirect_url("about:redirected");
   response->new_url = redirect_url;
   ipc_sender_.PushTask(
@@ skipping 41 matching lines @@
 
 }  // namespace
 
 void ExtensionWebRequestTest::FireURLRequestWithData(
     const std::string& method,
     const char* content_type,
     const std::vector<char>& bytes_1,
     const std::vector<char>& bytes_2) {
   // The request URL can be arbitrary but must have an HTTP or HTTPS scheme.
   GURL request_url("http://www.example.com");
-  scoped_ptr<net::URLRequest> request(context_->CreateRequest(
-      request_url, net::DEFAULT_PRIORITY, &delegate_));
+  std::unique_ptr<net::URLRequest> request(
+      context_->CreateRequest(request_url, net::DEFAULT_PRIORITY, &delegate_));
   request->set_method(method);
   if (content_type != NULL) {
     request->SetExtraRequestHeaderByName(net::HttpRequestHeaders::kContentType,
                                          content_type,
                                          true /* overwrite */);
   }
-  std::vector<scoped_ptr<net::UploadElementReader>> element_readers;
-  element_readers.push_back(make_scoped_ptr(
+  std::vector<std::unique_ptr<net::UploadElementReader>> element_readers;
+  element_readers.push_back(base::WrapUnique(
       new net::UploadBytesElementReader(&(bytes_1[0]), bytes_1.size())));
-  element_readers.push_back(make_scoped_ptr(new net::UploadFileElementReader(
+  element_readers.push_back(base::WrapUnique(new net::UploadFileElementReader(
       base::ThreadTaskRunnerHandle::Get().get(), base::FilePath(), 0, 0,
       base::Time())));
-  element_readers.push_back(make_scoped_ptr(
+  element_readers.push_back(base::WrapUnique(
       new net::UploadBytesElementReader(&(bytes_2[0]), bytes_2.size())));
-  request->set_upload(make_scoped_ptr(
+  request->set_upload(base::WrapUnique(
       new net::ElementsUploadDataStream(std::move(element_readers), 0)));
   ipc_sender_.PushTask(base::Bind(&base::DoNothing));
   request->Start();
 }
 
 TEST_F(ExtensionWebRequestTest, AccessRequestBodyData) {
   // We verify that URLRequest body is accessible to OnBeforeRequest listeners.
   // These testing steps are repeated twice in a row:
   // 1. Register an extension requesting "requestBody" in ExtraInfoSpec and
   //    file a POST URLRequest with a multipart-encoded form. See it getting
@@ skipping 40 matching lines @@
   const std::string kErrorPath(kBodyPath + "." + keys::kRequestBodyErrorKey);
   const std::string* const kPath[] = {
     &kFormDataPath,
     &kBodyPath,
     &kRawPath,
     &kRawPath
   };
   // Contents of formData.
   const char kFormData[] =
       "{\"A\":[\"test text\"],\"B\":[\"\"],\"C\":[\"test password\"]}";
-  scoped_ptr<const base::Value> form_data = base::JSONReader::Read(kFormData);
+  std::unique_ptr<const base::Value> form_data =
+      base::JSONReader::Read(kFormData);
   ASSERT_TRUE(form_data.get() != NULL);
   ASSERT_TRUE(form_data->GetType() == base::Value::TYPE_DICTIONARY);
   // Contents of raw.
   base::ListValue raw;
   extensions::subtle::AppendKeyValuePair(
       keys::kRequestBodyRawBytesKey,
       BinaryValue::CreateWithCopiedBuffer(kPlainBlock1, kPlainBlock1Length),
       &raw);
   extensions::subtle::AppendKeyValuePair(
       keys::kRequestBodyRawFileKey,
@@ skipping 196 matching lines @@
   // Subscribe to OnBeforeRequest with requestBody requirement.
   ExtensionWebRequestEventRouter::GetInstance()->AddEventListener(
       &profile_, extension_id, extension_id, events::FOR_TEST, kEventName,
       kEventName + "/1", filter, extra_info_spec, 0, 0,
       ipc_sender_factory.GetWeakPtr());
 
   // The request URL can be arbitrary but must have an HTTP or HTTPS scheme.
   const GURL request_url("http://www.example.com");
 
   for (size_t i = 0; i < arraysize(kMethods); ++i) {
-    scoped_ptr<net::URLRequest> request(context_->CreateRequest(
+    std::unique_ptr<net::URLRequest> request(context_->CreateRequest(
         request_url, net::DEFAULT_PRIORITY, &delegate_));
     request->set_method(kMethods[i]);
     ipc_sender_.PushTask(base::Bind(&base::DoNothing));
     request->Start();
   }
 
   // We inspect the result in the message list of |ipc_sender_| later.
   base::MessageLoop::current()->RunUntilIdle();
 
   ExtensionWebRequestEventRouter::GetInstance()->RemoveEventListener(
@@ skipping 68 matching lines @@
   }
 
   content::TestBrowserThreadBundle thread_bundle_;
   TestingProfile profile_;
   TestingProfileManager profile_manager_;
   net::TestDelegate delegate_;
   BooleanPrefMember enable_referrers_;
   TestIPCSender ipc_sender_;
   scoped_refptr<EventRouterForwarder> event_router_;
   scoped_refptr<InfoMap> extension_info_map_;
-  scoped_ptr<ChromeNetworkDelegate> network_delegate_;
-  scoped_ptr<net::MockHostResolver> host_resolver_;
-  scoped_ptr<net::TestURLRequestContext> context_;
+  std::unique_ptr<ChromeNetworkDelegate> network_delegate_;
+  std::unique_ptr<net::MockHostResolver> host_resolver_;
+  std::unique_ptr<net::TestURLRequestContext> context_;
 };
 
 TEST_P(ExtensionWebRequestHeaderModificationTest, TestModifications) {
   std::string extension1_id("1");
   std::string extension2_id("2");
   std::string extension3_id("3");
   ExtensionWebRequestEventRouter::RequestFilter filter;
   const std::string kEventName(keys::kOnBeforeSendHeadersEvent);
   base::WeakPtrFactory<TestIPCSender> ipc_sender_factory(&ipc_sender_);
 
   // Install two extensions that can modify headers. Extension 2 has
   // higher precedence than extension 1.
   ExtensionWebRequestEventRouter::GetInstance()->AddEventListener(
       &profile_, extension1_id, extension1_id, events::FOR_TEST, kEventName,
       kEventName + "/1", filter, ExtraInfoSpec::BLOCKING, 0, 0,
       ipc_sender_factory.GetWeakPtr());
   ExtensionWebRequestEventRouter::GetInstance()->AddEventListener(
       &profile_, extension2_id, extension2_id, events::FOR_TEST, kEventName,
       kEventName + "/2", filter, ExtraInfoSpec::BLOCKING, 0, 0,
       ipc_sender_factory.GetWeakPtr());
 
   // Install one extension that observes the final headers.
   ExtensionWebRequestEventRouter::GetInstance()->AddEventListener(
       &profile_, extension3_id, extension3_id, events::FOR_TEST,
       keys::kOnSendHeadersEvent, std::string(keys::kOnSendHeadersEvent) + "/3",
       filter, ExtraInfoSpec::REQUEST_HEADERS, 0, 0,
       ipc_sender_factory.GetWeakPtr());
 
   GURL request_url("http://doesnotexist/does_not_exist.html");
-  scoped_ptr<net::URLRequest> request(context_->CreateRequest(
-      request_url, net::DEFAULT_PRIORITY, &delegate_));
+  std::unique_ptr<net::URLRequest> request(
+      context_->CreateRequest(request_url, net::DEFAULT_PRIORITY, &delegate_));
 
   // Initialize headers available before extensions are notified of the
   // onBeforeSendHeaders event.
   HeaderModificationTest test = GetParam();
   net::HttpRequestHeaders before_headers;
   for (int i = 0; i < test.before_size; ++i)
     before_headers.SetHeader(test.before[i].name, test.before[i].value);
   request->SetExtraRequestHeaders(before_headers);
 
   // Gather the modifications to the headers for the respective extensions.
@@ skipping 322 matching lines @@
   base::ListValue list_value;
   list_value.Append(new base::FundamentalValue('1'));
   list_value.Append(new base::FundamentalValue('2'));
   list_value.Append(new base::FundamentalValue('3'));
   list_value.Append(new base::FundamentalValue(0xFE));
   list_value.Append(new base::FundamentalValue(0xD1));
 
   unsigned char char_value[] = {'1', '2', '3', 0xFE, 0xD1};
   std::string string_value(reinterpret_cast<char *>(char_value), 5);
 
-  scoped_ptr<base::ListValue> converted_list(StringToCharList(string_value));
+  std::unique_ptr<base::ListValue> converted_list(
+      StringToCharList(string_value));
   EXPECT_TRUE(list_value.Equals(converted_list.get()));
 
   std::string converted_string;
   EXPECT_TRUE(CharListToString(&list_value, &converted_string));
   EXPECT_EQ(string_value, converted_string);
 }
 
 TEST(ExtensionWebRequestHelpersTest, TestCalculateOnBeforeRequestDelta) {
   const bool cancel = true;
   const GURL localhost("http://localhost");
-  scoped_ptr<EventResponseDelta> delta(
-      CalculateOnBeforeRequestDelta("extid", base::Time::Now(),
-          cancel, localhost));
+  std::unique_ptr<EventResponseDelta> delta(CalculateOnBeforeRequestDelta(
+      "extid", base::Time::Now(), cancel, localhost));
   ASSERT_TRUE(delta.get());
   EXPECT_TRUE(delta->cancel);
   EXPECT_EQ(localhost, delta->new_url);
 }
 
 TEST(ExtensionWebRequestHelpersTest, TestCalculateOnBeforeSendHeadersDelta) {
   const bool cancel = true;
   std::string value;
   net::HttpRequestHeaders old_headers;
   old_headers.AddHeadersFromString("key1: value1\r\n"
                                    "key2: value2\r\n");
 
   // Test adding a header.
   net::HttpRequestHeaders new_headers_added;
   new_headers_added.AddHeadersFromString("key1: value1\r\n"
                                          "key3: value3\r\n"
                                          "key2: value2\r\n");
-  scoped_ptr<EventResponseDelta> delta_added(
+  std::unique_ptr<EventResponseDelta> delta_added(
       CalculateOnBeforeSendHeadersDelta("extid", base::Time::Now(), cancel,
-          &old_headers, &new_headers_added));
+                                        &old_headers, &new_headers_added));
   ASSERT_TRUE(delta_added.get());
   EXPECT_TRUE(delta_added->cancel);
   ASSERT_TRUE(delta_added->modified_request_headers.GetHeader("key3", &value));
   EXPECT_EQ("value3", value);
 
   // Test deleting a header.
   net::HttpRequestHeaders new_headers_deleted;
   new_headers_deleted.AddHeadersFromString("key1: value1\r\n");
-  scoped_ptr<EventResponseDelta> delta_deleted(
+  std::unique_ptr<EventResponseDelta> delta_deleted(
       CalculateOnBeforeSendHeadersDelta("extid", base::Time::Now(), cancel,
-          &old_headers, &new_headers_deleted));
+                                        &old_headers, &new_headers_deleted));
   ASSERT_TRUE(delta_deleted.get());
   ASSERT_EQ(1u, delta_deleted->deleted_request_headers.size());
   ASSERT_EQ("key2", delta_deleted->deleted_request_headers.front());
 
   // Test modifying a header.
   net::HttpRequestHeaders new_headers_modified;
   new_headers_modified.AddHeadersFromString("key1: value1\r\n"
                                             "key2: value3\r\n");
-  scoped_ptr<EventResponseDelta> delta_modified(
+  std::unique_ptr<EventResponseDelta> delta_modified(
       CalculateOnBeforeSendHeadersDelta("extid", base::Time::Now(), cancel,
-          &old_headers, &new_headers_modified));
+                                        &old_headers, &new_headers_modified));
   ASSERT_TRUE(delta_modified.get());
   EXPECT_TRUE(delta_modified->deleted_request_headers.empty());
   ASSERT_TRUE(
       delta_modified->modified_request_headers.GetHeader("key2", &value));
   EXPECT_EQ("value3", value);
 
   // Test modifying a header if extension author just appended a new (key,
   // value) pair with a key that existed before. This is incorrect
   // usage of the API that shall be handled gracefully.
   net::HttpRequestHeaders new_headers_modified2;
   new_headers_modified2.AddHeadersFromString("key1: value1\r\n"
                                              "key2: value2\r\n"
                                              "key2: value3\r\n");
-  scoped_ptr<EventResponseDelta> delta_modified2(
+  std::unique_ptr<EventResponseDelta> delta_modified2(
       CalculateOnBeforeSendHeadersDelta("extid", base::Time::Now(), cancel,
-          &old_headers, &new_headers_modified));
+                                        &old_headers, &new_headers_modified));
   ASSERT_TRUE(delta_modified2.get());
   EXPECT_TRUE(delta_modified2->deleted_request_headers.empty());
   ASSERT_TRUE(
       delta_modified2->modified_request_headers.GetHeader("key2", &value));
   EXPECT_EQ("value3", value);
 }
 
 TEST(ExtensionWebRequestHelpersTest, TestCalculateOnHeadersReceivedDelta) {
   const bool cancel = true;
   char base_headers_string[] =
       "HTTP/1.0 200 OK\r\n"
       "Key1: Value1\r\n"
       "Key2: Value2, Bar\r\n"
       "Key3: Value3\r\n"
       "Key5: Value5, end5\r\n"
       "\r\n";
   scoped_refptr<net::HttpResponseHeaders> base_headers(
       new net::HttpResponseHeaders(
         net::HttpUtil::AssembleRawHeaders(
             base_headers_string, sizeof(base_headers_string))));
 
   ResponseHeaders new_headers;
   new_headers.push_back(ResponseHeader("kEy1", "Value1"));  // Unchanged
   new_headers.push_back(ResponseHeader("Key2", "Value1"));  // Modified
   // Key3 is deleted
   new_headers.push_back(ResponseHeader("Key4", "Value4"));  // Added
   new_headers.push_back(ResponseHeader("Key5", "Value5, end5"));  // Unchanged
   GURL effective_new_url;
 
-  scoped_ptr<EventResponseDelta> delta(
-      CalculateOnHeadersReceivedDelta("extid",
-                                      base::Time::Now(),
-                                      cancel,
-                                      effective_new_url,
-                                      base_headers.get(),
-                                      &new_headers));
+  std::unique_ptr<EventResponseDelta> delta(CalculateOnHeadersReceivedDelta(
+      "extid", base::Time::Now(), cancel, effective_new_url, base_headers.get(),
+      &new_headers));
   ASSERT_TRUE(delta.get());
   EXPECT_TRUE(delta->cancel);
   EXPECT_EQ(2u, delta->added_response_headers.size());
   EXPECT_TRUE(Contains(delta->added_response_headers,
                        ResponseHeader("Key2", "Value1")));
   EXPECT_TRUE(Contains(delta->added_response_headers,
                        ResponseHeader("Key4", "Value4")));
   EXPECT_EQ(2u, delta->deleted_response_headers.size());
   EXPECT_TRUE(Contains(delta->deleted_response_headers,
                         ResponseHeader("Key2", "Value2, Bar")));
   EXPECT_TRUE(Contains(delta->deleted_response_headers,
                        ResponseHeader("Key3", "Value3")));
 }
 
 TEST(ExtensionWebRequestHelpersTest, TestCalculateOnAuthRequiredDelta) {
   const bool cancel = true;
 
   base::string16 username = base::ASCIIToUTF16("foo");
   base::string16 password = base::ASCIIToUTF16("bar");
-  scoped_ptr<net::AuthCredentials> credentials(
+  std::unique_ptr<net::AuthCredentials> credentials(
       new net::AuthCredentials(username, password));
 
-  scoped_ptr<EventResponseDelta> delta(
-      CalculateOnAuthRequiredDelta("extid", base::Time::Now(), cancel,
-          &credentials));
+  std::unique_ptr<EventResponseDelta> delta(CalculateOnAuthRequiredDelta(
+      "extid", base::Time::Now(), cancel, &credentials));
   ASSERT_TRUE(delta.get());
   EXPECT_TRUE(delta->cancel);
   ASSERT_TRUE(delta->auth_credentials.get());
   EXPECT_EQ(username, delta->auth_credentials->username());
   EXPECT_EQ(password, delta->auth_credentials->password());
 }
 
 TEST(ExtensionWebRequestHelpersTest, TestMergeCancelOfResponses) {
   EventResponseDeltas deltas;
   net::BoundTestNetLog capturing_net_log;
@@ skipping 902 matching lines @@
   EXPECT_TRUE(credentials_set);
   EXPECT_FALSE(auth3.Empty());
   EXPECT_EQ(username, auth1.username());
   EXPECT_EQ(password, auth1.password());
   EXPECT_EQ(1u, warning_set.size());
   EXPECT_TRUE(HasWarning(warning_set, "extid2"));
   EXPECT_EQ(3u, capturing_net_log.GetSize());
 }
 
 }  // namespace extensions