Refactor screenshot directory source

chrome/browser/ui/webui/screenshot_source.cc

 // Copyright (c) 2012 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/webui/screenshot_source.h"
 
+#if defined(USE_ASH)
+#include "ash/shell.h"
+#include "ash/shell_delegate.h"
+#endif

[Jun Mukai, 2012/09/11 01:56:18]

nit: move #if defined... includes after the normal includes.

[Harry McCleave, 2012/09/12 02:18:34]

Done.

+
 #include "base/bind.h"
 #include "base/callback.h"
+#include "base/file_path.h"
 #include "base/file_util.h"
+#include "base/i18n/time_formatting.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/string16.h"
+#include "base/stringprintf.h"
 #include "base/string_util.h"
+#include "chrome/browser/browser_process.h"
 #include "chrome/browser/download/download_prefs.h"
+#include "chrome/browser/prefs/pref_service.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/chrome_paths.h"
+#include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "googleurl/src/url_canon.h"
 #include "googleurl/src/url_util.h"
 
 #if defined(OS_CHROMEOS)
-#include "ash/shell.h"
-#include "ash/shell_delegate.h"
 #include "chrome/browser/chromeos/gdata/drive_file_system_interface.h"
 #include "chrome/browser/chromeos/gdata/drive_file_system_util.h"
 #include "chrome/browser/chromeos/gdata/drive_system_service.h"
+#include "chrome/browser/chromeos/gdata/gdata_util.h"
+#include "chrome/browser/chromeos/login/user_manager.h"
 #include "content/public/browser/browser_thread.h"
 #endif
 
-static const char kCurrentScreenshotFilename[] = "current";
+const char ScreenshotSource::kScreenshotUrlRoot[] = "chrome://screenshots/";
+const char ScreenshotSource::kScreenshotCurrent[] = "current";
+const char ScreenshotSource::kScreenshotSaved[] = "saved/";
 #if defined(OS_CHROMEOS)
-static const char kSavedScreenshotsBasePath[] = "saved/";
+const char ScreenshotSource::kScreenshotPrefix[] = "Screenshot ";
+const char ScreenshotSource::kScreenshotSuffix[] = ".png";
 #endif
 
+bool ShouldUse24HourClock() {
+#if defined(OS_CHROMEOS)
+  Profile* profile = ProfileManager::GetDefaultProfileOrOffTheRecord();
+  if (profile) {
+    PrefService* pref_service = profile->GetPrefs();
+    if (pref_service) {
+      return pref_service->GetBoolean(prefs::kUse24HourClock);
+    }
+  }
+#endif
+  return base::GetHourClockType() == base::k24HourClock;
+}
+
 ScreenshotSource::ScreenshotSource(
     std::vector<unsigned char>* current_screenshot,
     Profile* profile)
     : DataSource(chrome::kChromeUIScreenshotPath, MessageLoop::current()),
       profile_(profile) {
   // Setup the last screenshot taken.
   if (current_screenshot)
     current_screenshot_.reset(new ScreenshotData(*current_screenshot));
   else
     current_screenshot_.reset(new ScreenshotData());
 }
 
 ScreenshotSource::~ScreenshotSource() {}
 
+std::string ScreenshotSource::GetScreenshotBaseFilename() {
+  base::Time::Exploded now;
+  base::Time::Now().LocalExplode(&now);
+
+  // We don't use base/i18n/time_formatting.h here because it doesn't
+  // support our format.  Don't use ICU either to avoid i18n file names
+  // for non-English locales.
+  // TODO(mukai): integrate this logic somewhere time_formatting.h
+  std::string file_name = base::StringPrintf(
+      "Screenshot %d-%02d-%02d at ", now.year, now.month, now.day_of_month);
+
+  if (ShouldUse24HourClock()) {
+    file_name.append(base::StringPrintf(
+        "%02d.%02d.%02d", now.hour, now.minute, now.second));
+  } else {
+    int hour = now.hour;
+    if (hour > 12) {
+      hour -= 12;
+    } else if (hour == 0) {
+      hour = 12;
+    }
+    file_name.append(base::StringPrintf(
+        "%d.%02d.%02d ", hour, now.minute, now.second));
+    file_name.append((now.hour >= 12) ? "PM" : "AM");
+  }
+
+  return file_name;
+}
+
+#if defined(USE_ASH)
+
+bool ScreenshotSource::AreScreenshotsDisabled() {
+  return g_browser_process->local_state()->GetBoolean(
+      prefs::kDisableScreenshots);
+}
+
+bool ScreenshotSource::GetScreenshotDirectory(FilePath* directory) {
+  if (ScreenshotSource::AreScreenshotsDisabled())
+    return false;
+
+  bool is_logged_in = true;
+
+#if defined(OS_CHROMEOS)
+  is_logged_in = chromeos::UserManager::Get()->IsUserLoggedIn();
+#endif
+
+  if (is_logged_in) {
+    DownloadPrefs* download_prefs = DownloadPrefs::FromBrowserContext(
+        ash::Shell::GetInstance()->delegate()->GetCurrentBrowserContext());
+    *directory = download_prefs->DownloadPath();
+  } else  {
+    if (!file_util::GetTempDir(directory)) {
+      LOG(ERROR) << "Failed to find temporary directory.";
+      return false;
+    }
+  }
+  return true;
+}
+
+#endif
+
 void ScreenshotSource::StartDataRequest(const std::string& path, bool,
                                         int request_id) {
   SendScreenshot(path, request_id);
 }
 
 std::string ScreenshotSource::GetMimeType(const std::string&) const {
   // We need to explicitly return a mime type, otherwise if the user tries to
   // drag the image they get no extension.
   return "image/png";
 }
 
 ScreenshotDataPtr ScreenshotSource::GetCachedScreenshot(
     const std::string& screenshot_path) {
   std::map<std::string, ScreenshotDataPtr>::iterator pos;
   std::string path = screenshot_path.substr(
       0, screenshot_path.find_first_of("?"));
   if ((pos = cached_screenshots_.find(path)) != cached_screenshots_.end()) {
     return pos->second;
   } else {
     return ScreenshotDataPtr(new ScreenshotData);
   }
 }
 
 void ScreenshotSource::SendScreenshot(const std::string& screenshot_path,
                                       int request_id) {
   // Strip the query param value - we only use it as a hack to ensure our
   // image gets reloaded instead of being pulled from the browser cache
   std::string path = screenshot_path.substr(
       0, screenshot_path.find_first_of("?"));
-  if (path == kCurrentScreenshotFilename) {
+  if (path == ScreenshotSource::kScreenshotCurrent) {
     CacheAndSendScreenshot(path, request_id, current_screenshot_);
 #if defined(OS_CHROMEOS)
-  } else if (path.compare(0, strlen(kSavedScreenshotsBasePath),
-                          kSavedScreenshotsBasePath) == 0) {
+  } else if (path.compare(0, strlen(ScreenshotSource::kScreenshotSaved),
+             ScreenshotSource::kScreenshotSaved) == 0) {
     using content::BrowserThread;
 
-    std::string filename = path.substr(strlen(kSavedScreenshotsBasePath));
+    std::string filename =
+                       path.substr(strlen(ScreenshotSource::kScreenshotSaved));
 
     url_canon::RawCanonOutputT<char16> decoded;
     url_util::DecodeURLEscapeSequences(
         filename.data(), filename.size(), &decoded);
     // Screenshot filenames don't use non-ascii characters.
     std::string decoded_filename = UTF16ToASCII(string16(
         decoded.data(), decoded.length()));
 
-    DownloadPrefs* download_prefs = DownloadPrefs::FromBrowserContext(
-        ash::Shell::GetInstance()->delegate()->GetCurrentBrowserContext());
-    FilePath download_path = download_prefs->DownloadPath();
+    FilePath download_path;
+    GetScreenshotDirectory(&download_path);
     if (gdata::util::IsUnderDriveMountPoint(download_path)) {
       gdata::DriveFileSystemInterface* file_system =
           gdata::DriveSystemServiceFactory::GetForProfile(
               profile_)->file_system();
       file_system->GetFileByResourceId(
           decoded_filename,
           base::Bind(&ScreenshotSource::GetSavedScreenshotCallback,
                      base::Unretained(this), screenshot_path, request_id),
           gdata::GetContentCallback());
     } else {
@@ skipping 52 matching lines @@
 }
 #endif
 
 void ScreenshotSource::CacheAndSendScreenshot(
     const std::string& screenshot_path,
     int request_id,
     ScreenshotDataPtr bytes) {
   cached_screenshots_[screenshot_path] = bytes;
   SendResponse(request_id, new base::RefCountedBytes(*bytes));
 }