Remove use of linked_ptr from ExtensionWarningSet

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 <map>
 #include <queue>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/file_util.h"
@@ skipping 61 matching lines @@
 
 // Searches |key| in |collection| by iterating over its elements and returns
 // true if found.
 template <typename Collection, typename Key>
 bool Contains(const Collection& collection, const Key& key) {
   return std::find(collection.begin(), collection.end(), key) !=
       collection.end();
 }
 
 // Returns whether |warnings| contains an extension for |extension_id|.
-bool HasWarning(const std::set<linked_ptr<ExtensionWarning> > warnings,
+bool HasWarning(const ExtensionWarningSet::Set& warnings,
                 const std::string& extension_id) {
-  for (std::set<linked_ptr<ExtensionWarning> >::const_iterator i =
-           warnings.begin();
+  for (ExtensionWarningSet::Set::const_iterator i = warnings.begin();
        i != warnings.end();
        ++i) {
     if ((*i)->extension_id() == extension_id)
       return true;
   }
   return false;
 }
 
+void ClearWarnings(ExtensionWarningSet::Set* warnings) {
+  // We cannot delete elements that are still in the set because operator<
+  // cannot be executed on freed pointers that are still in the set.
+  std::vector<ExtensionWarning*> tmp(warnings->begin(), warnings->end());
+  warnings->clear();
+  STLDeleteContainerPointers(tmp.begin(), tmp.end());
+}
+
 }  // namespace
 
 // A mock event router that responds to events with a pre-arranged queue of
 // Tasks.
 class TestIPCSender : public IPC::Sender {
  public:
   typedef std::list<linked_ptr<IPC::Message> > SentMessages;
 
   // Adds a Task to the queue. We will fire these in order as events are
   // dispatched.
@@ skipping 910 matching lines @@
   MergeCancelOfResponses(deltas, &canceled, &net_log);
   EXPECT_TRUE(canceled);
   EXPECT_EQ(1u, capturing_net_log.GetSize());
 }
 
 TEST(ExtensionWebRequestHelpersTest, TestMergeOnBeforeRequestResponses) {
   EventResponseDeltas deltas;
   net::CapturingBoundNetLog capturing_net_log;
   net::BoundNetLog net_log = capturing_net_log.bound();
   ExtensionWarningSet warning_set;
-  std::set<linked_ptr<ExtensionWarning> > warnings;
+  ExtensionWarningSet::Set warnings;
   GURL effective_new_url;
 
   // No redirect
   linked_ptr<EventResponseDelta> d0(
       new EventResponseDelta("extid0", base::Time::FromInternalValue(0)));
   deltas.push_back(d0);
   MergeOnBeforeRequestResponses(
       deltas, &effective_new_url, &warning_set, &net_log);
   EXPECT_TRUE(effective_new_url.is_empty());
 
   // Single redirect.
   GURL new_url_1("http://foo.com");
   linked_ptr<EventResponseDelta> d1(
       new EventResponseDelta("extid1", base::Time::FromInternalValue(1000)));
   d1->new_url = GURL(new_url_1);
   deltas.push_back(d1);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   capturing_net_log.Clear();
   MergeOnBeforeRequestResponses(
       deltas, &effective_new_url, &warning_set, &net_log);
   warnings = warning_set.Release();
   EXPECT_EQ(new_url_1, effective_new_url);
   EXPECT_TRUE(warnings.empty());
   EXPECT_EQ(1u, capturing_net_log.GetSize());
+  ClearWarnings(&warnings);
 
   // Ignored redirect (due to precedence).
   GURL new_url_2("http://bar.com");
   linked_ptr<EventResponseDelta> d2(
       new EventResponseDelta("extid2", base::Time::FromInternalValue(500)));
   d2->new_url = GURL(new_url_2);
   deltas.push_back(d2);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   capturing_net_log.Clear();
   MergeOnBeforeRequestResponses(
       deltas, &effective_new_url, &warning_set, &net_log);
   warnings = warning_set.Release();
   EXPECT_EQ(new_url_1, effective_new_url);
   EXPECT_EQ(1u, warnings.size());
   EXPECT_TRUE(HasWarning(warnings, "extid2"));
   EXPECT_EQ(2u, capturing_net_log.GetSize());
+  ClearWarnings(&warnings);
 
   // Overriding redirect.
   GURL new_url_3("http://baz.com");
   linked_ptr<EventResponseDelta> d3(
       new EventResponseDelta("extid3", base::Time::FromInternalValue(1500)));
   d3->new_url = GURL(new_url_3);
   deltas.push_back(d3);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   capturing_net_log.Clear();
   MergeOnBeforeRequestResponses(
       deltas, &effective_new_url, &warning_set, &net_log);
   warnings = warning_set.Release();
   EXPECT_EQ(new_url_3, effective_new_url);
   EXPECT_EQ(2u, warnings.size());
   EXPECT_TRUE(HasWarning(warnings, "extid1"));
   EXPECT_TRUE(HasWarning(warnings, "extid2"));
   EXPECT_EQ(3u, capturing_net_log.GetSize());
+  ClearWarnings(&warnings);
 
   // Check that identical redirects don't cause a conflict.
   linked_ptr<EventResponseDelta> d4(
       new EventResponseDelta("extid4", base::Time::FromInternalValue(2000)));
   d4->new_url = GURL(new_url_3);
   deltas.push_back(d4);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   capturing_net_log.Clear();
   MergeOnBeforeRequestResponses(
       deltas, &effective_new_url, &warning_set, &net_log);
   warnings = warning_set.Release();
   EXPECT_EQ(new_url_3, effective_new_url);
   EXPECT_EQ(2u, warnings.size());
   EXPECT_TRUE(HasWarning(warnings, "extid1"));
   EXPECT_TRUE(HasWarning(warnings, "extid2"));
   EXPECT_EQ(4u, capturing_net_log.GetSize());
+  ClearWarnings(&warnings);
 }
 
 // This tests that we can redirect to data:// urls, which is considered
 // a kind of cancelling requests.
 TEST(ExtensionWebRequestHelpersTest, TestMergeOnBeforeRequestResponses2) {
   EventResponseDeltas deltas;
   net::CapturingBoundNetLog capturing_net_log;
   net::BoundNetLog net_log = capturing_net_log.bound();
   ExtensionWarningSet warning_set;
-  std::set<linked_ptr<ExtensionWarning> > warnings;
+  ExtensionWarningSet::Set warnings;
   GURL effective_new_url;
 
   // Single redirect.
   GURL new_url_0("http://foo.com");
   linked_ptr<EventResponseDelta> d0(
       new EventResponseDelta("extid0", base::Time::FromInternalValue(2000)));
   d0->new_url = GURL(new_url_0);
   deltas.push_back(d0);
   MergeOnBeforeRequestResponses(
       deltas, &effective_new_url, &warning_set, &net_log);
   warnings = warning_set.Release();
   EXPECT_EQ(new_url_0, effective_new_url);
+  ClearWarnings(&warnings);
 
   // Cancel request by redirecting to a data:// URL. This shall override
   // the other redirect but not cause any conflict warnings.
   GURL new_url_1("data://foo");
   linked_ptr<EventResponseDelta> d1(
       new EventResponseDelta("extid1", base::Time::FromInternalValue(1500)));
   d1->new_url = GURL(new_url_1);
   deltas.push_back(d1);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   capturing_net_log.Clear();
   MergeOnBeforeRequestResponses(
       deltas, &effective_new_url, &warning_set, &net_log);
   warnings = warning_set.Release();
   EXPECT_EQ(new_url_1, effective_new_url);
   EXPECT_TRUE(warnings.empty());
   EXPECT_EQ(1u, capturing_net_log.GetSize());
+  ClearWarnings(&warnings);
 
   // Cancel request by redirecting to the same data:// URL. This shall
   // not create any conflicts as it is in line with d1.
   GURL new_url_2("data://foo");
   linked_ptr<EventResponseDelta> d2(
       new EventResponseDelta("extid2", base::Time::FromInternalValue(1000)));
   d2->new_url = GURL(new_url_2);
   deltas.push_back(d2);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   capturing_net_log.Clear();
   MergeOnBeforeRequestResponses(
       deltas, &effective_new_url, &warning_set, &net_log);
   warnings = warning_set.Release();
   EXPECT_EQ(new_url_1, effective_new_url);
   EXPECT_TRUE(warnings.empty());
   EXPECT_EQ(2u, capturing_net_log.GetSize());
+  ClearWarnings(&warnings);
 
   // Cancel redirect by redirecting to a different data:// URL. This needs
   // to create a conflict.
   GURL new_url_3("data://something_totally_different");
   linked_ptr<EventResponseDelta> d3(
       new EventResponseDelta("extid3", base::Time::FromInternalValue(500)));
   d3->new_url = GURL(new_url_3);
   deltas.push_back(d3);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   capturing_net_log.Clear();
   MergeOnBeforeRequestResponses(
       deltas, &effective_new_url, &warning_set, &net_log);
   warnings = warning_set.Release();
   EXPECT_EQ(new_url_1, effective_new_url);
   EXPECT_EQ(1u, warnings.size());
   EXPECT_TRUE(HasWarning(warnings, "extid3"));
   EXPECT_EQ(3u, capturing_net_log.GetSize());
+  ClearWarnings(&warnings);
 }
 
 // This tests that we can redirect to about:blank, which is considered
 // a kind of cancelling requests.
 TEST(ExtensionWebRequestHelpersTest, TestMergeOnBeforeRequestResponses3) {
   EventResponseDeltas deltas;
   net::CapturingBoundNetLog capturing_net_log;
   net::BoundNetLog net_log = capturing_net_log.bound();
   ExtensionWarningSet warning_set;
-  std::set<linked_ptr<ExtensionWarning> > warnings;
+  ExtensionWarningSet::Set warnings;
   GURL effective_new_url;
 
   // Single redirect.
   GURL new_url_0("http://foo.com");
   linked_ptr<EventResponseDelta> d0(
       new EventResponseDelta("extid0", base::Time::FromInternalValue(2000)));
   d0->new_url = GURL(new_url_0);
   deltas.push_back(d0);
   MergeOnBeforeRequestResponses(
       deltas, &effective_new_url, &warning_set, &net_log);
   warnings = warning_set.Release();
   EXPECT_EQ(new_url_0, effective_new_url);
+  ClearWarnings(&warnings);
 
   // Cancel request by redirecting to about:blank. This shall override
   // the other redirect but not cause any conflict warnings.
   GURL new_url_1("about:blank");
   linked_ptr<EventResponseDelta> d1(
       new EventResponseDelta("extid1", base::Time::FromInternalValue(1500)));
   d1->new_url = GURL(new_url_1);
   deltas.push_back(d1);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   capturing_net_log.Clear();
   MergeOnBeforeRequestResponses(
       deltas, &effective_new_url, &warning_set, &net_log);
   warnings = warning_set.Release();
   EXPECT_EQ(new_url_1, effective_new_url);
   EXPECT_TRUE(warnings.empty());
   EXPECT_EQ(1u, capturing_net_log.GetSize());
+  ClearWarnings(&warnings);
 }
 
 TEST(ExtensionWebRequestHelpersTest, TestMergeOnBeforeSendHeadersResponses) {
   net::HttpRequestHeaders base_headers;
   base_headers.AddHeaderFromString("key1: value 1");
   base_headers.AddHeaderFromString("key2: value 2");
   net::CapturingBoundNetLog capturing_net_log;
   net::BoundNetLog net_log = capturing_net_log.bound();
   ExtensionWarningSet warning_set;
-  std::set<linked_ptr<ExtensionWarning> > warnings;
+  ExtensionWarningSet::Set warnings;
   std::string header_value;
   EventResponseDeltas deltas;
 
   // Check that we can handle not changing the headers.
   linked_ptr<EventResponseDelta> d0(
       new EventResponseDelta("extid0", base::Time::FromInternalValue(2500)));
   deltas.push_back(d0);
   net::HttpRequestHeaders headers0;
   headers0.MergeFrom(base_headers);
   MergeOnBeforeSendHeadersResponses(deltas, &headers0, &warning_set, &net_log);
   warnings = warning_set.Release();
   ASSERT_TRUE(headers0.GetHeader("key1", &header_value));
   EXPECT_EQ("value 1", header_value);
   ASSERT_TRUE(headers0.GetHeader("key2", &header_value));
   EXPECT_EQ("value 2", header_value);
   EXPECT_EQ(0u, warnings.size());
   EXPECT_EQ(0u, capturing_net_log.GetSize());
+  ClearWarnings(&warnings);
 
   // Delete, modify and add a header.
   linked_ptr<EventResponseDelta> d1(
       new EventResponseDelta("extid1", base::Time::FromInternalValue(2000)));
   d1->deleted_request_headers.push_back("key1");
   d1->modified_request_headers.AddHeaderFromString("key2: value 3");
   d1->modified_request_headers.AddHeaderFromString("key3: value 3");
   deltas.push_back(d1);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   net::HttpRequestHeaders headers1;
   headers1.MergeFrom(base_headers);
   MergeOnBeforeSendHeadersResponses(deltas, &headers1, &warning_set, &net_log);
   warnings = warning_set.Release();
   EXPECT_FALSE(headers1.HasHeader("key1"));
   ASSERT_TRUE(headers1.GetHeader("key2", &header_value));
   EXPECT_EQ("value 3", header_value);
   ASSERT_TRUE(headers1.GetHeader("key3", &header_value));
   EXPECT_EQ("value 3", header_value);
   EXPECT_EQ(0u, warnings.size());
   EXPECT_EQ(1u, capturing_net_log.GetSize());
+  ClearWarnings(&warnings);
 
   // Check that conflicts are atomic, i.e. if one header modification
   // collides all other conflicts of the same extension are declined as well.
   linked_ptr<EventResponseDelta> d2(
       new EventResponseDelta("extid2", base::Time::FromInternalValue(1500)));
   // This one conflicts:
   d2->modified_request_headers.AddHeaderFromString("key3: value 0");
   d2->modified_request_headers.AddHeaderFromString("key4: value 4");
   deltas.push_back(d2);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   capturing_net_log.Clear();
   net::HttpRequestHeaders headers2;
   headers2.MergeFrom(base_headers);
   MergeOnBeforeSendHeadersResponses(deltas, &headers2, &warning_set, &net_log);
   warnings = warning_set.Release();
   EXPECT_FALSE(headers2.HasHeader("key1"));
   ASSERT_TRUE(headers2.GetHeader("key2", &header_value));
   EXPECT_EQ("value 3", header_value);
   ASSERT_TRUE(headers2.GetHeader("key3", &header_value));
   EXPECT_EQ("value 3", header_value);
   EXPECT_FALSE(headers2.HasHeader("key4"));
   EXPECT_EQ(1u, warnings.size());
   EXPECT_TRUE(HasWarning(warnings, "extid2"));
   EXPECT_EQ(2u, capturing_net_log.GetSize());
+  ClearWarnings(&warnings);
 
   // Check that identical modifications don't conflict and operations
   // can be merged.
   linked_ptr<EventResponseDelta> d3(
       new EventResponseDelta("extid3", base::Time::FromInternalValue(1000)));
   d3->deleted_request_headers.push_back("key1");
   d3->modified_request_headers.AddHeaderFromString("key2: value 3");
   d3->modified_request_headers.AddHeaderFromString("key5: value 5");
   deltas.push_back(d3);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   capturing_net_log.Clear();
   net::HttpRequestHeaders headers3;
   headers3.MergeFrom(base_headers);
   MergeOnBeforeSendHeadersResponses(deltas, &headers3, &warning_set, &net_log);
   warnings = warning_set.Release();
   EXPECT_FALSE(headers3.HasHeader("key1"));
   ASSERT_TRUE(headers3.GetHeader("key2", &header_value));
   EXPECT_EQ("value 3", header_value);
   ASSERT_TRUE(headers3.GetHeader("key3", &header_value));
   EXPECT_EQ("value 3", header_value);
   ASSERT_TRUE(headers3.GetHeader("key5", &header_value));
   EXPECT_EQ("value 5", header_value);
   EXPECT_EQ(1u, warnings.size());
   EXPECT_TRUE(HasWarning(warnings, "extid2"));
   EXPECT_EQ(3u, capturing_net_log.GetSize());
+  ClearWarnings(&warnings);
 }
 
 TEST(ExtensionWebRequestHelpersTest,
      TestMergeOnBeforeSendHeadersResponses_Cookies) {
   net::HttpRequestHeaders base_headers;
   base_headers.AddHeaderFromString(
       "Cookie: name=value; name2=value2; name3=value3");
   net::CapturingBoundNetLog capturing_net_log;
   net::BoundNetLog net_log = capturing_net_log.bound();
   ExtensionWarningSet warning_set;
-  std::set<linked_ptr<ExtensionWarning> > warnings;
+  ExtensionWarningSet::Set warnings;
   std::string header_value;
   EventResponseDeltas deltas;
 
   linked_ptr<RequestCookieModification> add_cookie =
       make_linked_ptr(new RequestCookieModification);
   add_cookie->type = helpers::ADD;
   add_cookie->modification.reset(new helpers::RequestCookie);
   add_cookie->modification->name.reset(new std::string("name4"));
   add_cookie->modification->value.reset(new std::string("\"value 4\""));
 
@@ skipping 31 matching lines @@
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   net::HttpRequestHeaders headers1;
   headers1.MergeFrom(base_headers);
   MergeOnBeforeSendHeadersResponses(deltas, &headers1, &warning_set, &net_log);
   warnings = warning_set.Release();
   EXPECT_TRUE(headers1.HasHeader("Cookie"));
   ASSERT_TRUE(headers1.GetHeader("Cookie", &header_value));
   EXPECT_EQ("name=new value; name2=new value; name4=\"value 4\"", header_value);
   EXPECT_EQ(0u, warnings.size());
   EXPECT_EQ(0u, capturing_net_log.GetSize());
+  ClearWarnings(&warnings);
 }
 
 TEST(ExtensionWebRequestHelpersTest,
      TestMergeCookiesInOnHeadersReceivedResponses) {
   net::CapturingBoundNetLog capturing_net_log;
   net::BoundNetLog net_log = capturing_net_log.bound();
   ExtensionWarningSet warning_set;
-  std::set<linked_ptr<ExtensionWarning> > warnings;
+  ExtensionWarningSet::Set warnings;
   std::string header_value;
   EventResponseDeltas deltas;
 
   char base_headers_string[] =
       "HTTP/1.0 200 OK\r\n"
       "Foo: Bar\r\n"
       "Set-Cookie: name=value; DOMAIN=google.com; Secure\r\n"
       "Set-Cookie: name2=value2\r\n"
       "Set-Cookie: name3=value3\r\n"
       "\r\n";
   scoped_refptr<net::HttpResponseHeaders> base_headers(
       new net::HttpResponseHeaders(
           net::HttpUtil::AssembleRawHeaders(
               base_headers_string, sizeof(base_headers_string))));
 
   // Check that we can handle if not touching the response headers.
   linked_ptr<EventResponseDelta> d0(
       new EventResponseDelta("extid0", base::Time::FromInternalValue(3000)));
   deltas.push_back(d0);
   scoped_refptr<net::HttpResponseHeaders> new_headers0;
   MergeCookiesInOnHeadersReceivedResponses(
         deltas, base_headers.get(), &new_headers0, &warning_set, &net_log);
   warnings = warning_set.Release();
   EXPECT_FALSE(new_headers0.get());
   EXPECT_EQ(0u, warnings.size());
   EXPECT_EQ(0u, capturing_net_log.GetSize());
+  ClearWarnings(&warnings);
 
   linked_ptr<ResponseCookieModification> add_cookie =
       make_linked_ptr(new ResponseCookieModification);
   add_cookie->type = helpers::ADD;
   add_cookie->modification.reset(new helpers::ResponseCookie);
   add_cookie->modification->name.reset(new std::string("name4"));
   add_cookie->modification->value.reset(new std::string("\"value4\""));
 
   linked_ptr<ResponseCookieModification> edit_cookie =
       make_linked_ptr(new ResponseCookieModification);
@@ skipping 29 matching lines @@
   }
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   scoped_refptr<net::HttpResponseHeaders> headers1(
       new net::HttpResponseHeaders(
           net::HttpUtil::AssembleRawHeaders(
               base_headers_string, sizeof(base_headers_string))));
   scoped_refptr<net::HttpResponseHeaders> new_headers1;
   MergeCookiesInOnHeadersReceivedResponses(
       deltas, headers1.get(), &new_headers1, &warning_set, &net_log);
   warnings = warning_set.Release();
+  ClearWarnings(&warnings);
 
   EXPECT_TRUE(new_headers1->HasHeader("Foo"));
   void* iter = NULL;
   std::string cookie_string;
   std::set<std::string> expected_cookies;
   expected_cookies.insert("name=value; domain=google.com; secure");
   expected_cookies.insert("name2=value2; secure");
   expected_cookies.insert("name4=\"value4\"; secure");
   std::set<std::string> actual_cookies;
   while (new_headers1->EnumerateHeader(&iter, "Set-Cookie", &cookie_string))
     actual_cookies.insert(cookie_string);
   EXPECT_EQ(expected_cookies, actual_cookies);
   EXPECT_EQ(0u, warnings.size());
   EXPECT_EQ(0u, capturing_net_log.GetSize());
 }
 
 TEST(ExtensionWebRequestHelpersTest, TestMergeOnHeadersReceivedResponses) {
   net::CapturingBoundNetLog capturing_net_log;
   net::BoundNetLog net_log = capturing_net_log.bound();
   ExtensionWarningSet warning_set;
-  std::set<linked_ptr<ExtensionWarning> > warnings;
+  ExtensionWarningSet::Set warnings;
   std::string header_value;
   EventResponseDeltas deltas;
 
   char base_headers_string[] =
       "HTTP/1.0 200 OK\r\n"
       "Key1: Value1\r\n"
       "Key2: Value2, Foo\r\n"
       "\r\n";
   scoped_refptr<net::HttpResponseHeaders> base_headers(
       new net::HttpResponseHeaders(
         net::HttpUtil::AssembleRawHeaders(
             base_headers_string, sizeof(base_headers_string))));
 
   // Check that we can handle if not touching the response headers.
   linked_ptr<EventResponseDelta> d0(
       new EventResponseDelta("extid0", base::Time::FromInternalValue(3000)));
   deltas.push_back(d0);
   scoped_refptr<net::HttpResponseHeaders> new_headers0;
   MergeOnHeadersReceivedResponses(deltas, base_headers.get(), &new_headers0,
                                   &warning_set, &net_log);
   warnings = warning_set.Release();
   EXPECT_FALSE(new_headers0.get());
   EXPECT_EQ(0u, warnings.size());
   EXPECT_EQ(0u, capturing_net_log.GetSize());
+  ClearWarnings(&warnings);
 
   linked_ptr<EventResponseDelta> d1(
       new EventResponseDelta("extid1", base::Time::FromInternalValue(2000)));
   d1->deleted_response_headers.push_back(ResponseHeader("KEY1", "Value1"));
   d1->deleted_response_headers.push_back(ResponseHeader("KEY2", "Value2, Foo"));
   d1->added_response_headers.push_back(ResponseHeader("Key2", "Value3"));
   deltas.push_back(d1);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   capturing_net_log.Clear();
   scoped_refptr<net::HttpResponseHeaders> new_headers1;
   MergeOnHeadersReceivedResponses(
       deltas, base_headers.get(), &new_headers1, &warning_set, &net_log);
   warnings = warning_set.Release();
   ASSERT_TRUE(new_headers1.get());
   std::multimap<std::string, std::string> expected1;
   expected1.insert(std::pair<std::string, std::string>("Key2", "Value3"));
   void* iter = NULL;
   std::string name;
   std::string value;
   std::multimap<std::string, std::string> actual1;
   while (new_headers1->EnumerateHeaderLines(&iter, &name, &value)) {
     actual1.insert(std::pair<std::string, std::string>(name, value));
   }
   EXPECT_EQ(expected1, actual1);
   EXPECT_EQ(0u, warnings.size());
   EXPECT_EQ(1u, capturing_net_log.GetSize());
+  ClearWarnings(&warnings);
 
   // Check that we replace response headers only once.
   linked_ptr<EventResponseDelta> d2(
       new EventResponseDelta("extid2", base::Time::FromInternalValue(1500)));
   // Note that we use a different capitalization of KeY2. This should not
   // matter.
   d2->deleted_response_headers.push_back(ResponseHeader("KeY2", "Value2, Foo"));
   d2->added_response_headers.push_back(ResponseHeader("Key2", "Value4"));
   deltas.push_back(d2);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   capturing_net_log.Clear();
   scoped_refptr<net::HttpResponseHeaders> new_headers2;
   MergeOnHeadersReceivedResponses(
       deltas, base_headers.get(), &new_headers2, &warning_set, &net_log);
   warnings = warning_set.Release();
   ASSERT_TRUE(new_headers2.get());
   iter = NULL;
   std::multimap<std::string, std::string> actual2;
   while (new_headers2->EnumerateHeaderLines(&iter, &name, &value)) {
     actual2.insert(std::pair<std::string, std::string>(name, value));
   }
   EXPECT_EQ(expected1, actual2);
   EXPECT_EQ(1u, warnings.size());
   EXPECT_TRUE(HasWarning(warnings, "extid2"));
   EXPECT_EQ(2u, capturing_net_log.GetSize());
+  ClearWarnings(&warnings);
 }
 
 // Check that we do not delete too much
 TEST(ExtensionWebRequestHelpersTest,
      TestMergeOnHeadersReceivedResponsesDeletion) {
   net::CapturingBoundNetLog capturing_net_log;
   net::BoundNetLog net_log = capturing_net_log.bound();
   ExtensionWarningSet warning_set;
-  std::set<linked_ptr<ExtensionWarning> > warnings;
+  ExtensionWarningSet::Set warnings;
   std::string header_value;
   EventResponseDeltas deltas;
 
   char base_headers_string[] =
       "HTTP/1.0 200 OK\r\n"
       "Key1: Value1\r\n"
       "Key1: Value2\r\n"
       "Key1: Value3\r\n"
       "Key2: Value4\r\n"
       "\r\n";
@@ skipping 18 matching lines @@
   void* iter = NULL;
   std::string name;
   std::string value;
   std::multimap<std::string, std::string> actual1;
   while (new_headers1->EnumerateHeaderLines(&iter, &name, &value)) {
     actual1.insert(std::pair<std::string, std::string>(name, value));
   }
   EXPECT_EQ(expected1, actual1);
   EXPECT_EQ(0u, warnings.size());
   EXPECT_EQ(1u, capturing_net_log.GetSize());
+  ClearWarnings(&warnings);
 }
 
 TEST(ExtensionWebRequestHelpersTest, TestMergeOnAuthRequiredResponses) {
   net::CapturingBoundNetLog capturing_net_log;
   net::BoundNetLog net_log = capturing_net_log.bound();
   ExtensionWarningSet warning_set;
-  std::set<linked_ptr<ExtensionWarning> > warnings;
+  ExtensionWarningSet::Set warnings;
   EventResponseDeltas deltas;
   string16 username = ASCIIToUTF16("foo");
   string16 password = ASCIIToUTF16("bar");
   string16 password2 = ASCIIToUTF16("baz");
 
   // Check that we can handle if not returning credentials.
   linked_ptr<EventResponseDelta> d0(
       new EventResponseDelta("extid0", base::Time::FromInternalValue(3000)));
   deltas.push_back(d0);
   net::AuthCredentials auth0;
   bool credentials_set = MergeOnAuthRequiredResponses(
       deltas, &auth0, &warning_set, &net_log);
   warnings = warning_set.Release();
   EXPECT_FALSE(credentials_set);
   EXPECT_TRUE(auth0.Empty());
   EXPECT_EQ(0u, warnings.size());
   EXPECT_EQ(0u, capturing_net_log.GetSize());
+  ClearWarnings(&warnings);
 
   // Check that we can set AuthCredentials.
   linked_ptr<EventResponseDelta> d1(
       new EventResponseDelta("extid1", base::Time::FromInternalValue(2000)));
   d1->auth_credentials.reset(new net::AuthCredentials(username, password));
   deltas.push_back(d1);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   capturing_net_log.Clear();
   net::AuthCredentials auth1;
   credentials_set = MergeOnAuthRequiredResponses(
       deltas, &auth1, &warning_set, &net_log);
   warnings = warning_set.Release();
   EXPECT_TRUE(credentials_set);
   EXPECT_FALSE(auth1.Empty());
   EXPECT_EQ(username, auth1.username());
   EXPECT_EQ(password, auth1.password());
   EXPECT_EQ(0u, warnings.size());
   EXPECT_EQ(1u, capturing_net_log.GetSize());
+  ClearWarnings(&warnings);
 
   // Check that we set AuthCredentials only once.
   linked_ptr<EventResponseDelta> d2(
       new EventResponseDelta("extid2", base::Time::FromInternalValue(1500)));
   d2->auth_credentials.reset(new net::AuthCredentials(username, password2));
   deltas.push_back(d2);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   capturing_net_log.Clear();
   net::AuthCredentials auth2;
   credentials_set = MergeOnAuthRequiredResponses(
       deltas, &auth2, &warning_set, &net_log);
   warnings = warning_set.Release();
   EXPECT_TRUE(credentials_set);
   EXPECT_FALSE(auth2.Empty());
   EXPECT_EQ(username, auth1.username());
   EXPECT_EQ(password, auth1.password());
   EXPECT_EQ(1u, warnings.size());
   EXPECT_TRUE(HasWarning(warnings, "extid2"));
   EXPECT_EQ(2u, capturing_net_log.GetSize());
+  ClearWarnings(&warnings);
 
   // Check that we can set identical AuthCredentials twice without causing
   // a conflict.
   linked_ptr<EventResponseDelta> d3(
       new EventResponseDelta("extid3", base::Time::FromInternalValue(1000)));
   d3->auth_credentials.reset(new net::AuthCredentials(username, password));
   deltas.push_back(d3);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   capturing_net_log.Clear();
   net::AuthCredentials auth3;
   credentials_set = MergeOnAuthRequiredResponses(
       deltas, &auth3, &warning_set, &net_log);
   warnings = warning_set.Release();
   EXPECT_TRUE(credentials_set);
   EXPECT_FALSE(auth3.Empty());
   EXPECT_EQ(username, auth1.username());
   EXPECT_EQ(password, auth1.password());
   EXPECT_EQ(1u, warnings.size());
   EXPECT_TRUE(HasWarning(warnings, "extid2"));
   EXPECT_EQ(3u, capturing_net_log.GetSize());
+  ClearWarnings(&warnings);
 }
 
 }  // namespace extensions