Reduce visibility of methods in AutofillManager and AutofillDownload.

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 46 matching lines @@
 // AutofillDownloadManager. Then it records responses to different initiated
 // requests, which are verified later. To mock network requests
 // TestURLFetcherFactory is used, which creates URLFetchers that do not
 // go over the wire, but allow calling back HTTP responses directly.
 // The responses in test are out of order and verify: successful query request,
 // successful upload request, failed upload request.
 class AutofillDownloadTest : public AutofillDownloadManager::Observer,
                              public testing::Test {
  public:
   AutofillDownloadTest()
-      : download_manager_(&profile_),
+      : download_manager_(&profile_, this),
         io_thread_(BrowserThread::IO) {
   }
 
   virtual void SetUp() {
     base::Thread::Options options;
     options.message_loop_type = MessageLoop::TYPE_IO;
     io_thread_.StartWithOptions(options);
     profile_.CreateRequestContext();
-    download_manager_.SetObserver(this);
   }
 
   virtual void TearDown() {
     profile_.ResetRequestContext();
     io_thread_.Stop();
-    download_manager_.SetObserver(NULL);
   }
 
   void LimitCache(size_t cache_size) {
     download_manager_.set_max_form_cache_size(cache_size);
   }
 
   // AutofillDownloadManager::Observer implementation.
-  virtual void OnLoadedServerPredictions(const std::string& response_xml) {
+  virtual void OnLoadedServerPredictions(
+      const std::string& response_xml) OVERRIDE {
     ResponseData response;
     response.response = response_xml;
     response.type_of_response = QUERY_SUCCESSFULL;
     responses_.push_back(response);
   }
 
-  virtual void OnUploadedPossibleFieldTypes() {
+  virtual void OnUploadedPossibleFieldTypes() OVERRIDE {
     ResponseData response;
     response.type_of_response = UPLOAD_SUCCESSFULL;
     responses_.push_back(response);
   }
 
   virtual void OnServerRequestError(
       const std::string& form_signature,
       AutofillDownloadManager::AutofillRequestType request_type,
-      int http_error) {
+      int http_error) OVERRIDE {
     ResponseData response;
     response.signature = form_signature;
     response.error = http_error;
     response.type_of_response =
         request_type == AutofillDownloadManager::REQUEST_QUERY ?
             REQUEST_QUERY_FAILED : REQUEST_UPLOAD_FAILED;
     responses_.push_back(response);
   }
 
   enum TYPE_OF_RESPONSE {

[dhollowa, 2011/10/26 15:58:33]

Please change this to ResponseType (or something).  ALL CAPs hurts.

[Ilya Sherman, 2011/10/26 23:06:32]

Done.

     QUERY_SUCCESSFULL,
     UPLOAD_SUCCESSFULL,
     REQUEST_QUERY_FAILED,
     REQUEST_UPLOAD_FAILED,
   };
 
   struct ResponseData {
     TYPE_OF_RESPONSE type_of_response;
     int error;
     std::string signature;
     std::string response;
-    ResponseData() : type_of_response(REQUEST_QUERY_FAILED), error(0) {
-    }
+
+    ResponseData() : type_of_response(REQUEST_QUERY_FAILED), error(0) {}
   };
   std::list<ResponseData> responses_;
 
   TestingProfile profile_;
   AutofillDownloadManager download_manager_;
 
  private:
   // |request_context_getter_| must be released on the IO thread.
   MessageLoop* io_thread_loop() { return io_thread_.message_loop(); }
   BrowserThread io_thread_;
@@ skipping 362 matching lines @@
                                                   mock_metric_logger));
   // No responses yet
   EXPECT_EQ(static_cast<size_t>(0), responses_.size());
 
   fetcher = factory.GetFetcherByID(3);
   ASSERT_TRUE(fetcher);
   FakeOnURLFetchComplete(fetcher, 200, std::string(responses[0]));
   ASSERT_EQ(static_cast<size_t>(1), responses_.size());
   EXPECT_EQ(responses[0], responses_.front().response);
 }