Fix for: Autofill should not ping the server again for the same form...

chrome/browser/autofill/autofill_download_unittest.cc

 // Copyright (c) 2011 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 <list>
 
 #include "base/string_util.h"
 #include "base/test/test_timeouts.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/autofill/autofill_download.h"
@@ skipping 35 matching lines @@
   AutoFillDownloadTestHelper()
       : download_manager(&profile) {
     download_manager.SetObserver(this);
     // For chromium builds forces Start*Request to actually execute.
     download_manager.is_testing_ = true;
   }
   ~AutoFillDownloadTestHelper() {
     download_manager.SetObserver(NULL);
   }
 
+  void LimitCache(size_t cache_size) {
+    download_manager.set_number_of_forms_to_cache(cache_size);
+  }
+
   // AutoFillDownloadManager::Observer overridables:
   virtual void OnLoadedAutoFillHeuristics(
       const std::string& heuristic_xml) {
     ResponseData response;
     response.response = heuristic_xml;
     response.type_of_response = QUERY_SUCCESSFULL;
     responses_.push_back(response);
   };
-
   virtual void OnUploadedAutoFillHeuristics(const std::string& form_signature) {
     ResponseData response;
     response.type_of_response = UPLOAD_SUCCESSFULL;
     responses_.push_back(response);
   }
   virtual void OnHeuristicsRequestError(
       const std::string& form_signature,
       AutoFillDownloadManager::AutoFillRequestType request_type,
       int http_error) {
     ResponseData response;
@@ skipping 194 matching lines @@
   helper.download_manager.SetPositiveUploadRate(0.0);
   helper.download_manager.SetNegativeUploadRate(0.0);
   // No actual requests for the next two calls, as we set upload rate to 0%.
   EXPECT_FALSE(helper.download_manager.StartUploadRequest(*(form_structures[0]),
                                                          true));
   EXPECT_FALSE(helper.download_manager.StartUploadRequest(*(form_structures[1]),
                                                          false));
   fetcher = factory.GetFetcherByID(3);
   EXPECT_EQ(NULL, fetcher);
 
+  // Modify form structures to miss the cache.

[dhollowa, 2011/01/25 23:33:02]

I'm curious why this is was added to the existing test.

[GeorgeY, 2011/01/25 23:51:30]

If we hit the cache, the request is always going to be successful, as we never
go over the wire, but the following test is specifically for failure due to the
requested server backoff.

+  form.fields.push_back(webkit_glue::FormField(ASCIIToUTF16("Address line 2"),
+                                               ASCIIToUTF16("address2"),
+                                               string16(),
+                                               ASCIIToUTF16("text"),
+                                               0,
+                                               false));
+  form_structure = new FormStructure(form);
+  form_structures.push_back(form_structure);
+
   // Request with id 3.
   EXPECT_CALL(mock_metric_logger, Log(AutoFillMetrics::QUERY_SENT)).Times(1);
   EXPECT_TRUE(helper.download_manager.StartQueryRequest(form_structures,
                                                         mock_metric_logger));
   fetcher = factory.GetFetcherByID(3);
   ASSERT_TRUE(fetcher);
   fetcher->set_backoff_delay(
       base::TimeDelta::FromMilliseconds(TestTimeouts::action_max_timeout_ms()));
   fetcher->delegate()->OnURLFetchComplete(fetcher, GURL(),
                                           net::URLRequestStatus(),
@@ skipping 33 matching lines @@
 
   // Upload requests should be ignored for the next 10 seconds.
   EXPECT_FALSE(helper.download_manager.StartUploadRequest(*(form_structures[0]),
               true));
   fetcher = factory.GetFetcherByID(5);
   EXPECT_EQ(NULL, fetcher);
 
   // Make sure consumer of URLFetcher does the right thing.
   URLFetcher::set_factory(NULL);
 }
+
+TEST(AutoFillDownloadTest, CacheQueryTest) {
+  MessageLoopForUI message_loop;
+  AutoFillDownloadTestHelper helper;
+  // Create and register factory.
+  TestURLFetcherFactory factory;
+  URLFetcher::set_factory(&factory);
+
+  FormData form;
+  form.method = ASCIIToUTF16("post");
+  form.fields.push_back(webkit_glue::FormField(ASCIIToUTF16("username"),
+                                               ASCIIToUTF16("username"),
+                                               string16(),
+                                               ASCIIToUTF16("text"),
+                                               0,
+                                               false));
+  form.fields.push_back(webkit_glue::FormField(ASCIIToUTF16("First Name"),
+                                               ASCIIToUTF16("firstname"),
+                                               string16(),
+                                               ASCIIToUTF16("text"),
+                                               0,
+                                               false));
+  form.fields.push_back(webkit_glue::FormField(ASCIIToUTF16("Last Name"),
+                                               ASCIIToUTF16("lastname"),
+                                               string16(),
+                                               ASCIIToUTF16("text"),
+                                               0,
+                                               false));
+  FormStructure *form_structure = new FormStructure(form);
+  ScopedVector<FormStructure> form_structures0;
+  form_structures0.push_back(form_structure);
+
+  form.fields.push_back(webkit_glue::FormField(ASCIIToUTF16("email"),
+                                               ASCIIToUTF16("email"),
+                                               string16(),
+                                               ASCIIToUTF16("text"),
+                                               0,
+                                               false));
+  // Slightly different form - so different request.
+  form_structure = new FormStructure(form);
+  ScopedVector<FormStructure> form_structures1;
+  form_structures1.push_back(form_structure);
+
+  form.fields.push_back(webkit_glue::FormField(ASCIIToUTF16("email2"),
+                                               ASCIIToUTF16("email2"),
+                                               string16(),
+                                               ASCIIToUTF16("text"),
+                                               0,
+                                               false));
+  // Slightly different form - so different request.
+  form_structure = new FormStructure(form);
+  ScopedVector<FormStructure> form_structures2;
+  form_structures2.push_back(form_structure);
+
+  // Limit cache to two forms.
+  helper.LimitCache(2);
+
+  const char *responses[] = {
+    "<autofillqueryresponse>"
+      "<field autofilltype=\"0\" />"
+      "<field autofilltype=\"3\" />"
+      "<field autofilltype=\"5\" />"
+    "</autofillqueryresponse>",
+    "<autofillqueryresponse>"
+      "<field autofilltype=\"0\" />"
+      "<field autofilltype=\"3\" />"
+      "<field autofilltype=\"5\" />"
+      "<field autofilltype=\"9\" />"
+    "</autofillqueryresponse>",
+    "<autofillqueryresponse>"
+      "<field autofilltype=\"0\" />"
+      "<field autofilltype=\"3\" />"
+      "<field autofilltype=\"5\" />"
+      "<field autofilltype=\"9\" />"
+      "<field autofilltype=\"0\" />"
+    "</autofillqueryresponse>",
+  };
+
+  // Request with id 0.
+  MockAutoFillMetrics mock_metric_logger;
+  EXPECT_CALL(mock_metric_logger, Log(AutoFillMetrics::QUERY_SENT)).Times(1);
+  EXPECT_TRUE(helper.download_manager.StartQueryRequest(form_structures0,
+                                                        mock_metric_logger));
+  // No responses yet
+  EXPECT_EQ(static_cast<size_t>(0), helper.responses_.size());
+
+  TestURLFetcher* fetcher = factory.GetFetcherByID(0);
+  ASSERT_TRUE(fetcher);
+  fetcher->delegate()->OnURLFetchComplete(fetcher, GURL(),
+                                          net::URLRequestStatus(),
+                                          200, ResponseCookies(),
+                                          std::string(responses[0]));
+  ASSERT_EQ(static_cast<size_t>(1), helper.responses_.size());
+  EXPECT_EQ(responses[0], helper.responses_.front().response);
+
+  helper.responses_.clear();
+
+  // No actual request - should be a cache hit.
+  EXPECT_CALL(mock_metric_logger, Log(AutoFillMetrics::QUERY_SENT)).Times(1);
+  EXPECT_TRUE(helper.download_manager.StartQueryRequest(form_structures0,
+                                                        mock_metric_logger));
+  // Data is available immediately from cache - no over-the-wire trip.
+  ASSERT_EQ(static_cast<size_t>(1), helper.responses_.size());
+  EXPECT_EQ(responses[0], helper.responses_.front().response);
+  helper.responses_.clear();
+
+  // Request with id 1.
+  EXPECT_CALL(mock_metric_logger, Log(AutoFillMetrics::QUERY_SENT)).Times(1);
+  EXPECT_TRUE(helper.download_manager.StartQueryRequest(form_structures1,
+                                                        mock_metric_logger));
+  // No responses yet
+  EXPECT_EQ(static_cast<size_t>(0), helper.responses_.size());
+
+  fetcher = factory.GetFetcherByID(1);
+  ASSERT_TRUE(fetcher);
+  fetcher->delegate()->OnURLFetchComplete(fetcher, GURL(),
+                                          net::URLRequestStatus(),
+                                          200, ResponseCookies(),
+                                          std::string(responses[1]));
+  ASSERT_EQ(static_cast<size_t>(1), helper.responses_.size());
+  EXPECT_EQ(responses[1], helper.responses_.front().response);
+
+  helper.responses_.clear();
+
+  // Request with id 2.
+  EXPECT_CALL(mock_metric_logger, Log(AutoFillMetrics::QUERY_SENT)).Times(1);
+  EXPECT_TRUE(helper.download_manager.StartQueryRequest(form_structures2,
+                                                        mock_metric_logger));
+
+  fetcher = factory.GetFetcherByID(2);
+  ASSERT_TRUE(fetcher);
+  fetcher->delegate()->OnURLFetchComplete(fetcher, GURL(),
+                                          net::URLRequestStatus(),
+                                          200, ResponseCookies(),
+                                          std::string(responses[2]));
+  ASSERT_EQ(static_cast<size_t>(1), helper.responses_.size());
+  EXPECT_EQ(responses[2], helper.responses_.front().response);
+
+  helper.responses_.clear();
+
+  // No actual requests - should be a cache hit.
+  EXPECT_CALL(mock_metric_logger, Log(AutoFillMetrics::QUERY_SENT)).Times(1);
+  EXPECT_TRUE(helper.download_manager.StartQueryRequest(form_structures1,
+                                                        mock_metric_logger));
+
+  EXPECT_CALL(mock_metric_logger, Log(AutoFillMetrics::QUERY_SENT)).Times(1);
+  EXPECT_TRUE(helper.download_manager.StartQueryRequest(form_structures2,
+                                                        mock_metric_logger));
+
+  ASSERT_EQ(static_cast<size_t>(2), helper.responses_.size());
+  EXPECT_EQ(responses[1], helper.responses_.front().response);
+  EXPECT_EQ(responses[2], helper.responses_.back().response);
+  helper.responses_.clear();
+
+  // The first structure should've expired.
+  // Request with id 3.
+  EXPECT_CALL(mock_metric_logger, Log(AutoFillMetrics::QUERY_SENT)).Times(1);
+  EXPECT_TRUE(helper.download_manager.StartQueryRequest(form_structures0,
+                                                        mock_metric_logger));
+  // No responses yet
+  EXPECT_EQ(static_cast<size_t>(0), helper.responses_.size());
+
+  fetcher = factory.GetFetcherByID(3);
+  ASSERT_TRUE(fetcher);
+  fetcher->delegate()->OnURLFetchComplete(fetcher, GURL(),
+                                          net::URLRequestStatus(),
+                                          200, ResponseCookies(),
+                                          std::string(responses[0]));
+  ASSERT_EQ(static_cast<size_t>(1), helper.responses_.size());
+  EXPECT_EQ(responses[0], helper.responses_.front().response);
+
+  // Make sure consumer of URLFetcher does the right thing.
+  URLFetcher::set_factory(NULL);
+}
+