Move safe_browsing.mojom into components/safe_browsing.

chrome/browser/safe_browsing/mojo_safe_browsing_impl.cc

 // Copyright 2017 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/mojo_safe_browsing_impl.h"
 
 #include <vector>
 
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
@@ skipping 26 matching lines @@
   if (!render_frame_host)
     return nullptr;
 
   return content::WebContents::FromRenderFrameHost(render_frame_host);
 }
 
 // TODO(yzshen): Handle the case where SafeBrowsing is not enabled, or
 // !database_manager()->IsSupported().
 // TODO(yzshen): Make sure it also works on Andorid.
 // TODO(yzshen): Do all the logging like what BaseResourceThrottle does.
-class SafeBrowsingUrlCheckerImpl : public chrome::mojom::SafeBrowsingUrlChecker,
+class SafeBrowsingUrlCheckerImpl : public mojom::SafeBrowsingUrlChecker,
                                    public SafeBrowsingDatabaseManager::Client {
  public:
   SafeBrowsingUrlCheckerImpl(
       int load_flags,
       content::ResourceType resource_type,
       scoped_refptr<SafeBrowsingDatabaseManager> database_manager,
       scoped_refptr<SafeBrowsingUIManager> ui_manager,
       int render_process_id,
       int render_frame_id)
       : load_flags_(load_flags),
@@ skipping 10 matching lines @@
   ~SafeBrowsingUrlCheckerImpl() override {
     DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
     if (state_ == STATE_CHECKING_URL)
       database_manager_->CancelCheck(this);
 
     for (size_t i = next_index_; i < callbacks_.size(); ++i)
       std::move(callbacks_[i]).Run(false);
   }
 
-  // chrome::mojom::SafeBrowsingUrlChecker implementation.
+  // mojom::SafeBrowsingUrlChecker implementation.
   void CheckUrl(const GURL& url, CheckUrlCallback callback) override {
     DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
     DVLOG(1) << "SafeBrowsingUrlCheckerImpl checks URL: " << url;
     urls_.push_back(url);
     callbacks_.push_back(std::move(callback));
 
     ProcessUrls();
   }
 
@@ skipping 182 matching lines @@
 MojoSafeBrowsingImpl::~MojoSafeBrowsingImpl() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 }
 
 // static
 void MojoSafeBrowsingImpl::Create(
     scoped_refptr<SafeBrowsingDatabaseManager> database_manager,
     scoped_refptr<SafeBrowsingUIManager> ui_manager,
     int render_process_id,
     const service_manager::BindSourceInfo& source_info,
-    chrome::mojom::SafeBrowsingRequest request) {
+    mojom::SafeBrowsingRequest request) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   mojo::MakeStrongBinding(base::MakeUnique<MojoSafeBrowsingImpl>(
                               std::move(database_manager),
                               std::move(ui_manager), render_process_id),
                           std::move(request));
 }
 
 void MojoSafeBrowsingImpl::CreateCheckerAndCheck(
     int32_t render_frame_id,
-    chrome::mojom::SafeBrowsingUrlCheckerRequest request,
+    mojom::SafeBrowsingUrlCheckerRequest request,
     const GURL& url,
     int32_t load_flags,
     content::ResourceType resource_type,
     CreateCheckerAndCheckCallback callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   auto checker_impl = base::MakeUnique<SafeBrowsingUrlCheckerImpl>(
       static_cast<int>(load_flags), resource_type, database_manager_,
       ui_manager_, render_process_id_, static_cast<int>(render_frame_id));
   checker_impl->CheckUrl(url, std::move(callback));
   mojo::MakeStrongBinding(std::move(checker_impl), std::move(request));
 }
 
 }  // namespace safe_browsing