Componentize safe_browsing: decouple threat_details* from the chrome/ layer.

chrome/browser/safe_browsing/threat_details.h

 // 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.
 
 #ifndef CHROME_BROWSER_SAFE_BROWSING_THREAT_DETAILS_H_
 #define CHROME_BROWSER_SAFE_BROWSING_THREAT_DETAILS_H_
 
 // A class that encapsulates the detailed threat reports sent when
 // users opt-in to do so from the safe browsing warning page.
 
 // An instance of this class is generated when a safe browsing warning page
 // is shown (SafeBrowsingBlockingPage).
 
 #include <memory>
 #include <string>
 #include <unordered_set>
 #include <vector>
 
 #include "base/containers/hash_tables.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "chrome/browser/safe_browsing/ui_manager.h"
 #include "components/safe_browsing/common/safebrowsing_types.h"
 #include "components/safe_browsing/csd.pb.h"
+#include "components/security_interstitials/content/unsafe_resource.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "net/base/completion_callback.h"
 
+namespace history {
+class HistoryService;
+}  // namespace history
+
 namespace net {
 class URLRequestContextGetter;
-}
+}  // namespace net
 
-class Profile;
 struct SafeBrowsingHostMsg_ThreatDOMDetails_Node;
 
 namespace safe_browsing {
 
+class BaseUIManager;
+
 // Maps a URL to its Resource.
 class ThreatDetailsCacheCollector;
 class ThreatDetailsRedirectsCollector;
 class ThreatDetailsFactory;
 
 using ResourceMap =
     base::hash_map<std::string,
                    std::unique_ptr<ClientSafeBrowsingReportRequest::Resource>>;
 
 // Maps a key of an HTML element to its corresponding HTMLElement proto message.
@@ skipping 16 matching lines @@
 using UrlToChildIdsMap = base::hash_map<std::string, std::unordered_set<int>>;
 
 class ThreatDetails : public base::RefCountedThreadSafe<
                           ThreatDetails,
                           content::BrowserThread::DeleteOnUIThread>,
                       public content::WebContentsObserver {
  public:
   typedef security_interstitials::UnsafeResource UnsafeResource;
 
   // Constructs a new ThreatDetails instance, using the factory.
-  static ThreatDetails* NewThreatDetails(BaseUIManager* ui_manager,
-                                         content::WebContents* web_contents,
-                                         const UnsafeResource& resource);
+  static ThreatDetails* NewThreatDetails(
+      BaseUIManager* ui_manager,
+      content::WebContents* web_contents,
+      const UnsafeResource& resource,
+      net::URLRequestContextGetter* request_context_getter,
+      history::HistoryService* history_service);
 
-  // Makes the passed |factory| the factory used to instanciate
+  // Makes the passed |factory| the factory used to instantiate
   // SafeBrowsingBlockingPage objects. Useful for tests.
   static void RegisterFactory(ThreatDetailsFactory* factory) {
     factory_ = factory;
   }
 
   // The SafeBrowsingBlockingPage calls this from the IO thread when
   // the user is leaving the blocking page and has opted-in to sending
   // the report. We start the redirection urls collection from history service
   // in UI thread; then do cache collection back in IO thread. We also record
   // if the user did proceed with the warning page, and how many times user
   // visited this page before. When we are done, we send the report.
   void FinishCollection(bool did_proceed, int num_visits);
 
   void OnCacheCollectionReady();
 
   void OnRedirectionCollectionReady();
 
   // content::WebContentsObserver implementation.
   bool OnMessageReceived(const IPC::Message& message,
                          content::RenderFrameHost* render_frame_host) override;
 
  protected:
   friend class ThreatDetailsFactoryImpl;
   friend class TestThreatDetailsFactory;
 
   ThreatDetails(BaseUIManager* ui_manager,
                 content::WebContents* web_contents,
-                const UnsafeResource& resource);
+                const UnsafeResource& resource,
+                net::URLRequestContextGetter* request_context_getter,
+                history::HistoryService* history_service);
 
   ~ThreatDetails() override;
 
   // Called on the IO thread with the DOM details.
   virtual void AddDOMDetails(
       const int frame_tree_node_id,
       const GURL& frame_last_committed_url,
       const std::vector<SafeBrowsingHostMsg_ThreatDOMDetails_Node>& params);
 
-  Profile* profile_;
-
   // The report protocol buffer.
   std::unique_ptr<ClientSafeBrowsingReportRequest> report_;
 
   // Used to get a pointer to the HTTP cache.
   scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
 
  private:
   friend class base::RefCountedThreadSafe<ThreatDetails>;
   friend struct content::BrowserThread::DeleteOnThread<
       content::BrowserThread::UI>;
@@ skipping 108 matching lines @@
 };
 
 // Factory for creating ThreatDetails.  Useful for tests.
 class ThreatDetailsFactory {
  public:
   virtual ~ThreatDetailsFactory() {}
 
   virtual ThreatDetails* CreateThreatDetails(
       BaseUIManager* ui_manager,
       content::WebContents* web_contents,
-      const SafeBrowsingUIManager::UnsafeResource& unsafe_resource) = 0;
+      const security_interstitials::UnsafeResource& unsafe_resource,
+      net::URLRequestContextGetter* request_context_getter,
+      history::HistoryService* history_service) = 0;
 };
 
 }  // namespace safe_browsing
 
 #endif  // CHROME_BROWSER_SAFE_BROWSING_THREAT_DETAILS_H_