Move code in components/safe_browsing_db and chrome/browser/s_b/ under the safe_browsing namespace.

chrome/browser/safe_browsing/srt_global_error_win.cc

 // Copyright 2014 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/srt_global_error_win.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
@@ skipping 11 matching lines @@
 #include "components/component_updater/pref_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using base::SingleThreadTaskRunner;
 using base::ThreadTaskRunnerHandle;
 using content::BrowserThread;
 
+namespace safe_browsing {
+
 namespace {
 
 // Used as a backup plan in case the SRT executable was not successfully
 // downloaded or run.
 const char kSRTDownloadURL[] =
     "https://www.google.com/chrome/srt/?chrome-prompt=1";
 
 // The extension to use to replace the temporary one created when the SRT was
 // downloaded.
 const base::FilePath::CharType kExecutableExtension[] = L"exe";
@@ skipping 56 matching lines @@
 
 int SRTGlobalError::MenuItemCommandID() {
   return IDC_SHOW_SRT_BUBBLE;
 }
 
 base::string16 SRTGlobalError::MenuItemLabel() {
   return l10n_util::GetStringUTF16(IDS_SRT_MENU_ITEM);
 }
 
 void SRTGlobalError::ExecuteMenuItem(Browser* browser) {
-  safe_browsing::RecordSRTPromptHistogram(
-      safe_browsing::SRT_PROMPT_SHOWN_FROM_MENU);
+  RecordSRTPromptHistogram(SRT_PROMPT_SHOWN_FROM_MENU);
   show_dismiss_button_ = true;
   ShowBubbleView(browser);
 }
 
 void SRTGlobalError::ShowBubbleView(Browser* browser) {
-  safe_browsing::RecordSRTPromptHistogram(safe_browsing::SRT_PROMPT_SHOWN);
+  RecordSRTPromptHistogram(SRT_PROMPT_SHOWN);
   GlobalErrorWithStandardBubble::ShowBubbleView(browser);
 }
 
 bool SRTGlobalError::ShouldShowCloseButton() const {
   return true;
 }
 
 base::string16 SRTGlobalError::GetBubbleViewTitle() {
   return l10n_util::GetStringUTF16(IDS_SRT_BUBBLE_TITLE);
 }
 
 std::vector<base::string16> SRTGlobalError::GetBubbleViewMessages() {
   std::vector<base::string16> messages;
   messages.push_back(l10n_util::GetStringUTF16(IDS_SRT_BUBBLE_TEXT));
   return messages;
 }
 
 base::string16 SRTGlobalError::GetBubbleViewAcceptButtonLabel() {
   return downloaded_path_.empty()
              ? l10n_util::GetStringUTF16(IDS_SRT_BUBBLE_DOWNLOAD_BUTTON_TEXT)
              : l10n_util::GetStringUTF16(IDS_SRT_BUBBLE_RUN_BUTTON_TEXT);
 }
 
 bool SRTGlobalError::ShouldAddElevationIconToAcceptButton() {
-  return !downloaded_path_.empty() &&
-         safe_browsing::SRTPromptNeedsElevationIcon();
+  return !downloaded_path_.empty() && SRTPromptNeedsElevationIcon();
 }
 
 base::string16 SRTGlobalError::GetBubbleViewCancelButtonLabel() {
   if (show_dismiss_button_)
     return l10n_util::GetStringUTF16(IDS_SRT_BUBBLE_DISMISS);
   return base::string16();
 }
 
 void SRTGlobalError::OnBubbleViewDidClose(Browser* browser) {
   // This won't happen when user interacted with the bubble since DestroySelf is
   // called in those cases and will prevent the base class from calling virtual
   // methods. This DCHECK makes sure that behavior won't change.
   DCHECK(!interacted_);
-  safe_browsing::RecordSRTPromptHistogram(safe_browsing::SRT_PROMPT_CLOSED);
+  RecordSRTPromptHistogram(SRT_PROMPT_CLOSED);
   g_browser_process->local_state()->SetBoolean(prefs::kSwReporterPendingPrompt,
                                                true);
 }
 
 void SRTGlobalError::BubbleViewAcceptButtonPressed(Browser* browser) {
-  safe_browsing::RecordSRTPromptHistogram(safe_browsing::SRT_PROMPT_ACCEPTED);
+  RecordSRTPromptHistogram(SRT_PROMPT_ACCEPTED);
   interacted_ = true;
   global_error_service_->RemoveGlobalError(this);
   MaybeExecuteSRT();
 }
 
 void SRTGlobalError::BubbleViewCancelButtonPressed(Browser* browser) {
-  safe_browsing::RecordSRTPromptHistogram(safe_browsing::SRT_PROMPT_DENIED);
+  RecordSRTPromptHistogram(SRT_PROMPT_DENIED);
   interacted_ = true;
   global_error_service_->RemoveGlobalError(this);
 
   BrowserThread::PostBlockingPoolTask(
       FROM_HERE, base::Bind(&DeleteFilesFromBlockingPool, downloaded_path_));
   DestroySelf();
 }
 
 bool SRTGlobalError::ShouldCloseOnDeactivate() const {
   return false;
@@ skipping 10 matching lines @@
   BrowserThread::PostBlockingPoolTask(
       FROM_HERE, base::Bind(&MaybeExecuteSRTFromBlockingPool, downloaded_path_,
                             base::ThreadTaskRunnerHandle::Get(),
                             base::Bind(&SRTGlobalError::DestroySelf,
                                        base::Unretained(this)),
                             base::Bind(&SRTGlobalError::FallbackToDownloadPage,
                                        base::Unretained(this))));
 }
 
 void SRTGlobalError::FallbackToDownloadPage() {
-  safe_browsing::RecordSRTPromptHistogram(safe_browsing::SRT_PROMPT_FALLBACK);
+  RecordSRTPromptHistogram(SRT_PROMPT_FALLBACK);
 
   chrome::HostDesktopType desktop_type = chrome::GetActiveDesktop();
   Browser* browser = chrome::FindLastActiveWithHostDesktopType(desktop_type);
   if (browser) {
     browser->OpenURL(content::OpenURLParams(
         GURL(kSRTDownloadURL), content::Referrer(), NEW_FOREGROUND_TAB,
         ui::PAGE_TRANSITION_LINK, false));
   }
 
   BrowserThread::PostBlockingPoolTask(
       FROM_HERE, base::Bind(&DeleteFilesFromBlockingPool, downloaded_path_));
   DestroySelf();
 }
 
 void SRTGlobalError::DestroySelf() {
   // This should only happen when user interacted with the bubble.
   DCHECK(interacted_);
   g_browser_process->local_state()->SetBoolean(prefs::kSwReporterPendingPrompt,
                                                false);
   delete this;
 }
+
+}  // namespace safe_browsing