Remove OS_CHROMEOS from ui/ash code

chrome/browser/ui/ash/chrome_screenshot_grabber.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/ui/ash/chrome_screenshot_grabber.h"
 
 #include <stddef.h>
 
 #include "ash/shell.h"
 #include "ash/system/system_notifier.h"
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_util.h"
 #include "base/i18n/time_formatting.h"
 #include "base/macros.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
+#include "chrome/browser/chromeos/drive/file_system_util.h"
+#include "chrome/browser/chromeos/file_manager/open_util.h"
 #include "chrome/browser/download/download_prefs.h"
 #include "chrome/browser/notifications/notification_ui_manager.h"
+#include "chrome/browser/notifications/notifier_state_tracker.h"
+#include "chrome/browser/notifications/notifier_state_tracker_factory.h"
 #include "chrome/browser/platform_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/pref_names.h"
+#include "chromeos/login/login_state.h"
+#include "components/drive/chromeos/file_system_interface.h"
 #include "components/prefs/pref_service.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/user_metrics.h"
 #include "grit/ash_strings.h"
 #include "grit/theme_resources.h"
 #include "ui/base/clipboard/clipboard.h"
 #include "ui/base/clipboard/scoped_clipboard_writer.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/strings/grit/ui_strings.h"
 
-#if defined(OS_CHROMEOS)
-#include "chrome/browser/chromeos/drive/file_system_util.h"
-#include "chrome/browser/chromeos/file_manager/open_util.h"
-#include "chrome/browser/notifications/notifier_state_tracker.h"
-#include "chrome/browser/notifications/notifier_state_tracker_factory.h"
-#include "chromeos/login/login_state.h"
-#include "components/drive/chromeos/file_system_interface.h"
-#endif
-
 namespace {
 
 const char kNotificationId[] = "screenshot";
 
-#if defined(OS_CHROMEOS)
 const char kNotificationOriginUrl[] = "chrome://screenshot";
-#endif
 
 const char kImageClipboardFormatPrefix[] = "<img src='data:image/png;base64,";
 const char kImageClipboardFormatSuffix[] = "'>";
 
 void CopyScreenshotToClipboard(scoped_refptr<base::RefCountedString> png_data) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   std::string encoded;
   base::Base64Encode(png_data->data(), &encoded);
 
@@ skipping 18 matching lines @@
     LOG(ERROR) << "Failed to read the screenshot file: "
                << screenshot_path.value();
     return;
   }
 
   content::BrowserThread::PostTask(
       content::BrowserThread::UI, FROM_HERE,
       base::Bind(CopyScreenshotToClipboard, png_data));
 }
 
-#if defined(OS_CHROMEOS)
 void ReadFileAndCopyToClipboardDrive(
     drive::FileError error,
     const base::FilePath& file_path,
     std::unique_ptr<drive::ResourceEntry> entry) {
   if (error != drive::FILE_ERROR_OK) {
     LOG(ERROR) << "Failed to read the screenshot path on drive: "
                << drive::FileErrorToString(error);
     return;
   }
   content::BrowserThread::GetBlockingPool()->PostTask(
       FROM_HERE, base::Bind(&ReadFileAndCopyToClipboardLocal, file_path));
 }
-#endif
 
 // Delegate for a notification. This class has two roles: to implement callback
 // methods for notification, and to provide an identity of the associated
 // notification.
 class ScreenshotGrabberNotificationDelegate : public NotificationDelegate {
  public:
   ScreenshotGrabberNotificationDelegate(bool success,
                                         Profile* profile,
                                         const base::FilePath& screenshot_path)
       : success_(success),
         profile_(profile),
         screenshot_path_(screenshot_path) {}
 
   // Overridden from NotificationDelegate:
   void Click() override {
     if (!success_)
       return;
     platform_util::ShowItemInFolder(profile_, screenshot_path_);
   }
   void ButtonClick(int button_index) override {
     DCHECK(success_ && button_index == 0);
 
-// To avoid keeping the screenshot image on memory, it will re-read the
-// screenshot file and copy it to the clipboard.
-#if defined(OS_CHROMEOS)
+    // To avoid keeping the screenshot image on memory, it will re-read the
+    // screenshot file and copy it to the clipboard.
     if (drive::util::IsUnderDriveMountPoint(screenshot_path_)) {
       drive::FileSystemInterface* file_system =
           drive::util::GetFileSystemByProfile(profile_);
       file_system->GetFile(drive::util::ExtractDrivePath(screenshot_path_),
                            base::Bind(&ReadFileAndCopyToClipboardDrive));
       return;
     }
-#endif
+
     content::BrowserThread::GetBlockingPool()->PostTask(
         FROM_HERE,
         base::Bind(&ReadFileAndCopyToClipboardLocal, screenshot_path_));
   }
   bool HasClickedListener() override { return success_; }
   std::string id() const override { return std::string(kNotificationId); }
 
  private:
   ~ScreenshotGrabberNotificationDelegate() override {}
 
   const bool success_;
   Profile* profile_;
   const base::FilePath screenshot_path_;
 
   DISALLOW_COPY_AND_ASSIGN(ScreenshotGrabberNotificationDelegate);
 };
 
-#if defined(OS_CHROMEOS)
 int GetScreenshotNotificationTitle(
     ui::ScreenshotGrabberObserver::Result screenshot_result) {
   switch (screenshot_result) {
     case ui::ScreenshotGrabberObserver::SCREENSHOTS_DISABLED:
       return IDS_ASH_SCREENSHOT_NOTIFICATION_TITLE_DISABLED;
     case ui::ScreenshotGrabberObserver::SCREENSHOT_SUCCESS:
       return IDS_ASH_SCREENSHOT_NOTIFICATION_TITLE_SUCCESS;
     default:
       return IDS_ASH_SCREENSHOT_NOTIFICATION_TITLE_FAIL;
   }
@@ skipping 34 matching lines @@
   } else {
     LOG(ERROR) << "Failed to ensure the existence of the specified directory "
                << "in Google Drive: " << error;
     content::BrowserThread::GetBlockingPool()->PostTask(
         FROM_HERE,
         base::Bind(callback,
                    ui::ScreenshotGrabberDelegate::FILE_CHECK_DIR_FAILED,
                    base::FilePath()));
   }
 }
-#endif
 
 bool ScreenshotsDisabled() {
   return g_browser_process->local_state()->GetBoolean(
       prefs::kDisableScreenshots);
 }
 
 bool ShouldUse24HourClock() {
-#if defined(OS_CHROMEOS)
   Profile* profile = ProfileManager::GetActiveUserProfile();
-  if (profile) {
+  if (profile)
     return profile->GetPrefs()->GetBoolean(prefs::kUse24HourClock);
-  }
-#endif
   return base::GetHourClockType() == base::k24HourClock;
 }
 
 bool GetScreenshotDirectory(base::FilePath* directory) {
-  bool is_logged_in = true;
-
-#if defined(OS_CHROMEOS)
-  is_logged_in = chromeos::LoginState::Get()->IsUserLoggedIn();
-#endif
-
-  if (is_logged_in) {
+  if (chromeos::LoginState::Get()->IsUserLoggedIn()) {
     DownloadPrefs* download_prefs = DownloadPrefs::FromBrowserContext(
         ProfileManager::GetActiveUserProfile());
     *directory = download_prefs->DownloadPath();
   } else {
     if (!base::GetTempDir(directory)) {
       LOG(ERROR) << "Failed to find temporary directory.";
       return false;
     }
   }
   return true;
@@ skipping 129 matching lines @@
 }
 
 bool ChromeScreenshotGrabber::CanTakeScreenshot() {
   return screenshot_grabber_->CanTakeScreenshot();
 }
 
 void ChromeScreenshotGrabber::PrepareFileAndRunOnBlockingPool(
     const base::FilePath& path,
     scoped_refptr<base::TaskRunner> blocking_task_runner,
     const FileCallback& callback) {
-#if defined(OS_CHROMEOS)
   Profile* profile = ProfileManager::GetActiveUserProfile();
   if (drive::util::IsUnderDriveMountPoint(path)) {
     drive::util::EnsureDirectoryExists(
         profile, path.DirName(),
         base::Bind(&EnsureDirectoryExistsCallback, callback, profile, path));
     return;
   }
-#endif
   ui::ScreenshotGrabberDelegate::PrepareFileAndRunOnBlockingPool(
       path, blocking_task_runner, callback);
 }
 
 void ChromeScreenshotGrabber::OnScreenshotCompleted(
     ui::ScreenshotGrabberObserver::Result result,
     const base::FilePath& screenshot_path) {
-#if defined(OS_CHROMEOS)
   // Do not show a notification that a screenshot was taken while no user is
   // logged in, since it is confusing for the user to get a message about it
   // after he logs in (crbug.com/235217).
   if (!chromeos::LoginState::Get()->IsUserLoggedIn())
     return;
 
   // TODO(sschmitz): make this work for Windows.
   NotifierStateTracker* const notifier_state_tracker =
       NotifierStateTrackerFactory::GetForProfile(GetProfile());
   if (notifier_state_tracker->IsNotifierEnabled(message_center::NotifierId(
           message_center::NotifierId::SYSTEM_COMPONENT,
           ash::system_notifier::kNotifierScreenshot))) {
     std::unique_ptr<Notification> notification(
         CreateNotification(result, screenshot_path));
     g_browser_process->notification_ui_manager()->Add(*notification,
                                                       GetProfile());
   }
-#endif
 }
 
-#if defined(OS_CHROMEOS)
 Notification* ChromeScreenshotGrabber::CreateNotification(
     ui::ScreenshotGrabberObserver::Result screenshot_result,
     const base::FilePath& screenshot_path) {
   const std::string notification_id(kNotificationId);
   // We cancel a previous screenshot notification, if any, to ensure we get
   // a fresh notification pop-up.
   g_browser_process->notification_ui_manager()->CancelById(
       notification_id, NotificationUIManager::GetProfileID(GetProfile()));
   bool success =
       (screenshot_result == ui::ScreenshotGrabberObserver::SCREENSHOT_SUCCESS);
@@ skipping 11 matching lines @@
           GetScreenshotNotificationText(screenshot_result)),
       ui::ResourceBundle::GetSharedInstance().GetImageNamed(
           IDR_SCREENSHOT_NOTIFICATION_ICON),
       message_center::NotifierId(message_center::NotifierId::SYSTEM_COMPONENT,
                                  ash::system_notifier::kNotifierScreenshot),
       l10n_util::GetStringUTF16(IDS_MESSAGE_CENTER_NOTIFIER_SCREENSHOT_NAME),
       GURL(kNotificationOriginUrl), notification_id, optional_field,
       new ScreenshotGrabberNotificationDelegate(success, GetProfile(),
                                                 screenshot_path));
 }
-#endif
 
 void ChromeScreenshotGrabber::SetProfileForTest(Profile* profile) {
   profile_for_test_ = profile;
 }
 
 Profile* ChromeScreenshotGrabber::GetProfile() {
   return profile_for_test_ ? profile_for_test_
                            : ProfileManager::GetActiveUserProfile();
 }