Add a browser test for safebrowsing service....

chrome/browser/safe_browsing/protocol_manager.cc

 // Copyright (c) 2010 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 "chrome/browser/safe_browsing/protocol_manager.h"
 
 #ifndef NDEBUG
 #include "base/base64.h"
 #endif
 #include "base/environment.h"
@@ skipping 19 matching lines @@
 
 // Maximum time, in seconds, from start up before we must issue an update query.
 static const int kSbTimerStartIntervalSec = 5 * 60;
 
 // The maximum time, in seconds, to wait for a response to an update request.
 static const int kSbMaxUpdateWaitSec = 10;
 
 // Maximum back off multiplier.
 static const int kSbMaxBackOff = 8;
 
+// The default SBProtocolManagerFactory.
+class SBProtocolManagerFactoryImpl : public SBProtocolManagerFactory {
+ public:
+  SBProtocolManagerFactoryImpl() { }
+  virtual ~SBProtocolManagerFactoryImpl() { }
+  virtual SafeBrowsingProtocolManager* CreateProtocolManager(
+      SafeBrowsingService* sb_service,
+      const std::string& client_name,
+      const std::string& client_key,
+      const std::string& wrapped_key,
+      URLRequestContextGetter* request_context_getter,
+      const std::string& info_url_prefix,
+      const std::string& mackey_url_prefix,
+      bool disable_auto_update) {
+    return new SafeBrowsingProtocolManager(
+        sb_service, client_name, client_key, wrapped_key,
+        request_context_getter, info_url_prefix, mackey_url_prefix,
+        disable_auto_update);
+  }
+ private:
+  DISALLOW_COPY_AND_ASSIGN(SBProtocolManagerFactoryImpl);
+};
 
 // SafeBrowsingProtocolManager implementation ----------------------------------
 
+// static
+SBProtocolManagerFactory* SafeBrowsingProtocolManager::factory_ = NULL;
+
+// static
+SafeBrowsingProtocolManager* SafeBrowsingProtocolManager::Create(
+    SafeBrowsingService* sb_service,
+    const std::string& client_name,
+    const std::string& client_key,
+    const std::string& wrapped_key,
+    URLRequestContextGetter* request_context_getter,
+    const std::string& info_url_prefix,
+    const std::string& mackey_url_prefix,
+    bool disable_auto_update) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  if (!factory_)
+    factory_ = new SBProtocolManagerFactoryImpl();
+  return factory_->CreateProtocolManager(sb_service, client_name, client_key,
+                                         wrapped_key, request_context_getter,
+                                         info_url_prefix, mackey_url_prefix,
+                                         disable_auto_update);
+}
+
 SafeBrowsingProtocolManager::SafeBrowsingProtocolManager(
     SafeBrowsingService* sb_service,
     const std::string& client_name,
     const std::string& client_key,
     const std::string& wrapped_key,
     URLRequestContextGetter* request_context_getter,
     const std::string& http_url_prefix,
     const std::string& https_url_prefix,
     bool disable_auto_update)
     : sb_service_(sb_service),
@@ skipping 146 matching lines @@
         // so that it doesn't hold up the user's request indefinitely. Not sure
         // what to do at that point though!
         full_hashes.clear();
       } else {
         if (re_key)
           HandleReKey();
       }
     } else {
       HandleGetHashError(Time::Now());
       if (status.status() == URLRequestStatus::FAILED) {
-          VLOG(1) << "SafeBrowsing GetHash request for: " << source->url()
-                  << " failed with os error: " << status.os_error();
+        VLOG(1) << "SafeBrowsing GetHash request for: " << source->url()
+                << " failed with os error: " << status.os_error();
       } else {
-          VLOG(1) << "SafeBrowsing GetHash request for: " << source->url()
-                  << " failed with error: " << response_code;
+        VLOG(1) << "SafeBrowsing GetHash request for: " << source->url()
+                << " failed with error: " << response_code;
       }
     }
 
     // Call back the SafeBrowsingService with full_hashes, even if there was a
     // parse error or an error response code (in which case full_hashes will be
     // empty). We can't block the user regardless of the error status.
     sb_service_->HandleGetHashResults(check, full_hashes, can_cache);
 
     hash_requests_.erase(it);
   } else {
@@ skipping 518 matching lines @@
   if (!additional_query_.empty()) {
     if (next_url.find("?") != std::string::npos) {
       next_url.append("&");
     } else {
       next_url.append("?");
     }
     next_url.append(additional_query_);
   }
   return GURL(next_url);
 }