Do not send or store cookies for extensions autoupdate http requests....

chrome/browser/extensions/extension_updater_unittest.cc

 // Copyright (c) 2009 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 "base/file_util.h"
 #include "base/rand_util.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "base/thread.h"
 #include "chrome/browser/extensions/extension_updater.h"
 #include "chrome/browser/extensions/extensions_service.h"
 #include "chrome/browser/net/test_url_fetcher_factory.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_error_reporter.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/pref_service.h"
 #include "net/base/escape.h"
+#include "net/base/load_flags.h"
 #include "net/url_request/url_request_status.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "libxml/globals.h"
 
-
+static int expected_load_flags =
+    net::LOAD_DO_NOT_SEND_COOKIES | net::LOAD_DO_NOT_SAVE_COOKIES;
 
 // Do-nothing base class for further specialized test classes.
 class MockService : public ExtensionUpdateService {
  public:
   MockService() {}
   virtual ~MockService() {}
 
   virtual const ExtensionList* extensions() const {
     EXPECT_TRUE(false);
     return NULL;
@@ skipping 327 matching lines @@
     GURL url2("http://localhost/manifest2");
 
     // Request 2 update checks - the first should begin immediately and the
     // second one should be queued up.
     updater->StartUpdateCheck(url1);
     updater->StartUpdateCheck(url2);
 
     std::string invalid_xml = "invalid xml";
     fetcher = factory.GetFetcherByID(ExtensionUpdater::kManifestFetcherId);
     EXPECT_TRUE(fetcher != NULL && fetcher->delegate() != NULL);
+    EXPECT_TRUE(fetcher->load_flags() == expected_load_flags);
     fetcher->delegate()->OnURLFetchComplete(
         fetcher, url1, URLRequestStatus(), 200, ResponseCookies(),
         invalid_xml);
 
     // Now that the first request is complete, make sure the second one has
     // been started.
     const std::string kValidXml =
         "<?xml version='1.0' encoding='UTF-8'?>"
         "<gupdate xmlns='http://www.google.com/update2/response'"
         "                protocol='2.0'>"
         " <app appid='12345'>"
         "  <updatecheck codebase='http://example.com/extension_1.2.3.4.crx'"
         "               version='1.2.3.4' prodversionmin='2.0.143.0' />"
         " </app>"
         "</gupdate>";
     fetcher = factory.GetFetcherByID(ExtensionUpdater::kManifestFetcherId);
     EXPECT_TRUE(fetcher != NULL && fetcher->delegate() != NULL);
+    EXPECT_TRUE(fetcher->load_flags() == expected_load_flags);
     fetcher->delegate()->OnURLFetchComplete(
         fetcher, url2, URLRequestStatus(), 200, ResponseCookies(),
         kValidXml);
 
     // This should run the manifest parsing, then we want to make sure that our
     // service was called with GetExtensionById with the matching id from
     // kValidXml.
     file_thread.Stop();
     io_thread.Stop();
     ui_loop.RunAllPending();
@@ skipping 20 matching lines @@
     std::string id = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
     std::string hash = "";
     std::string version = "0.0.1";
 
     updater->FetchUpdatedExtension(id, test_url, hash, version);
 
     // Call back the ExtensionUpdater with a 200 response and some test data
     std::string extension_data("whatever");
     fetcher = factory.GetFetcherByID(ExtensionUpdater::kExtensionFetcherId);
     EXPECT_TRUE(fetcher != NULL && fetcher->delegate() != NULL);
+    EXPECT_TRUE(fetcher->load_flags() == expected_load_flags);
     fetcher->delegate()->OnURLFetchComplete(
         fetcher, test_url, URLRequestStatus(), 200, ResponseCookies(),
         extension_data);
 
     file_thread.Stop();
     ui_loop.RunAllPending();
 
     // Expect that ExtensionUpdater asked the mock extensions service to install
     // a file with the test data for the right id.
     EXPECT_EQ(id, service.extension_id());
@@ skipping 27 matching lines @@
       "2CE109E9D0FAF820B2434E166297934E6177B65AB9951DBC3E204CAD4689B39C";
 
     std::string version = "0.0.1";
 
     updater->FetchUpdatedExtension(id, test_url, hash, version);
 
     // Call back the ExtensionUpdater with a 200 response and some test data
     std::string extension_data("aaabbb");
     fetcher = factory.GetFetcherByID(ExtensionUpdater::kExtensionFetcherId);
     EXPECT_TRUE(fetcher != NULL && fetcher->delegate() != NULL);
+    EXPECT_TRUE(fetcher->load_flags() == expected_load_flags);
     fetcher->delegate()->OnURLFetchComplete(
         fetcher, test_url, URLRequestStatus(), 200, ResponseCookies(),
         extension_data);
 
     message_loop.RunAllPending();
 
     // The updater should have called extension service to process the
     // blacklist.
     EXPECT_TRUE(service.processed_blacklist());
 
@@ skipping 26 matching lines @@
     std::string version1 = "0.1";
     std::string version2 = "0.1";
     // Start two fetches
     updater->FetchUpdatedExtension(id1, url1, hash1, version1);
     updater->FetchUpdatedExtension(id2, url2, hash2, version2);
 
     // Make the first fetch complete.
     std::string extension_data1("whatever");
     fetcher = factory.GetFetcherByID(ExtensionUpdater::kExtensionFetcherId);
     EXPECT_TRUE(fetcher != NULL && fetcher->delegate() != NULL);
+    EXPECT_TRUE(fetcher->load_flags() == expected_load_flags);
     fetcher->delegate()->OnURLFetchComplete(
         fetcher, url1, URLRequestStatus(), 200, ResponseCookies(),
         extension_data1);
     message_loop.RunAllPending();
 
     // Expect that the service was asked to do an install with the right data.
     FilePath tmpfile_path = service.install_path();
     EXPECT_FALSE(tmpfile_path.empty());
     EXPECT_EQ(id1, service.extension_id());
     message_loop.RunAllPending();
     file_util::Delete(tmpfile_path, false);
 
     // Make sure the second fetch finished and asked the service to do an
     // update.
     std::string extension_data2("whatever2");
     fetcher = factory.GetFetcherByID(ExtensionUpdater::kExtensionFetcherId);
     EXPECT_TRUE(fetcher != NULL && fetcher->delegate() != NULL);
+    EXPECT_TRUE(fetcher->load_flags() == expected_load_flags);
     fetcher->delegate()->OnURLFetchComplete(
         fetcher, url2, URLRequestStatus(), 200, ResponseCookies(),
         extension_data2);
     message_loop.RunAllPending();
     EXPECT_EQ(id2, service.extension_id());
     EXPECT_FALSE(service.install_path().empty());
 
     // Make sure the correct crx contents were passed for the update call.
     std::string file_contents;
     EXPECT_TRUE(file_util::ReadFileToString(service.install_path(),
@@ skipping 40 matching lines @@
 // -prodversionmin (shouldn't update if browser version too old)
 // -manifests & updates arriving out of order / interleaved
 // -Profile::GetDefaultRequestContext() returning null
 //  (should not crash, but just do check later)
 // -malformed update url (empty, file://, has query, has a # fragment, etc.)
 // -An extension gets uninstalled while updates are in progress (so it doesn't
 //  "come back from the dead")
 // -An extension gets manually updated to v3 while we're downloading v2 (ie
 //  you don't get downgraded accidentally)
 // -An update manifest mentions multiple updates