Refactor screenshot directory source

chrome/browser/ui/webui/feedback_ui.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/feedback_ui.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 58 matching lines @@
 #include "ui/aura/window.h"
 #endif
 
 using content::BrowserThread;
 using content::WebContents;
 using content::WebUIMessageHandler;
 using ui::WebDialogUI;
 
 namespace {
 
-const char kScreenshotBaseUrl[] = "chrome://screenshots/";
-const char kCurrentScreenshotUrl[] = "chrome://screenshots/current";
-
 const char kCategoryTagParameter[] = "categoryTag=";
 const char kDescriptionParameter[] = "description=";
 const char kSessionIDParameter[] = "session_id=";
 const char kTabIndexParameter[] = "tab_index=";
 const char kCustomPageUrlParameter[] = "customPageUrl=";
 
 #if defined(OS_CHROMEOS)
-const char kSavedScreenshotsUrl[] = "chrome://screenshots/saved/";
-const char kScreenshotPrefix[] = "Screenshot ";
-const char kScreenshotSuffix[] = ".png";
 
 const char kTimestampParameter[] = "timestamp=";
 
 const size_t kMaxSavedScreenshots = 2;
-#endif
-
-#if defined(OS_CHROMEOS)
 size_t kMaxNumScanFiles = 1000;
 
 // Compare two screenshot filepaths, which include the screenshot timestamp
 // in the format of screenshot-yyyymmdd-hhmmss.png. Return true if |filepath1|
 // is more recent |filepath2|.
 bool ScreenshotTimestampComp(const std::string& filepath1,
                              const std::string& filepath2) {
   return filepath1 > filepath2;
 }
 
@@ skipping 19 matching lines @@
                            scoped_ptr<gdata::DriveEntryProtoVector> entries) {
   if (error != gdata::DRIVE_FILE_OK) {
     callback.Run();
     return;
   }
 
   size_t max_scan = std::min(kMaxNumScanFiles, entries->size());
   std::vector<gdata::DriveEntryProto> screenshot_entries;
   for (size_t i = 0; i < max_scan; ++i) {
     const gdata::DriveEntryProto& entry = (*entries)[i];
-    if (StartsWithASCII(entry.base_name(), kScreenshotPrefix, true) &&
-        EndsWith(entry.base_name(), kScreenshotSuffix, true)) {
+    if (StartsWithASCII(entry.base_name(),
+                        ScreenshotSource::kScreenshotPrefix, true) &&
+        EndsWith(entry.base_name(),
+                 ScreenshotSource::kScreenshotSuffix, true)) {
       screenshot_entries.push_back(entry);
     }
   }
 
   size_t sort_size = std::min(max_saved, screenshot_entries.size());
   std::partial_sort(screenshot_entries.begin(),
                     screenshot_entries.begin() + sort_size,
                     screenshot_entries.end(),
                     ScreenshotDriveTimestampComp);
   for (size_t i = 0; i < sort_size; ++i) {
     const gdata::DriveEntryProto& entry = screenshot_entries[i];
     saved_screenshots->push_back(
-        std::string(kSavedScreenshotsUrl) + entry.resource_id());
+        std::string(ScreenshotSource::kScreenshotUrlRoot) +
+        std::string(ScreenshotSource::kScreenshotSaved) +
+        entry.resource_id());
   }
   callback.Run();
 }
 
 #else
 
 std::string GetUserEmail() {
   Profile* profile = ProfileManager::GetLastUsedProfile();
   if (!profile)
     return std::string();
@@ skipping 378 matching lines @@
 
   // On ChromeOS if the user's email is blank, it means we don't
   // have a logged in user, hence don't use saved screenshots.
   dialog_defaults.SetBoolean("useSaved", !user_email.empty());
 #endif
 
   web_ui()->CallJavascriptFunction("setupDialogDefaults", dialog_defaults);
 }
 
 void FeedbackHandler::HandleRefreshCurrentScreenshot(const ListValue*) {
-  std::string current_screenshot(kCurrentScreenshotUrl);
+  std::string current_screenshot(
+          std::string(ScreenshotSource::kScreenshotUrlRoot) +
+          std::string(ScreenshotSource::kScreenshotCurrent));
   StringValue screenshot(current_screenshot);
   web_ui()->CallJavascriptFunction("setupCurrentScreenshot", screenshot);
 }
 
 #if defined(OS_CHROMEOS)
 void FeedbackHandler::HandleRefreshSavedScreenshots(const ListValue*) {
   std::vector<std::string>* saved_screenshots = new std::vector<std::string>;
   FilePath filepath = DownloadPrefs::FromBrowserContext(
       tab_->GetBrowserContext())->DownloadPath();
   base::Closure refresh_callback = base::Bind(
@@ skipping 52 matching lines @@
   std::string page_url;
   (*i++)->GetAsString(&page_url);
   std::string category_tag;
   (*i++)->GetAsString(&category_tag);
   std::string description;
   (*i++)->GetAsString(&description);
   std::string user_email;
   (*i++)->GetAsString(&user_email);
   std::string screenshot_path;
   (*i++)->GetAsString(&screenshot_path);
-  screenshot_path.erase(0, strlen(kScreenshotBaseUrl));
+  screenshot_path.erase(0, strlen(ScreenshotSource::kScreenshotUrlRoot));
 
   // Get the image to send in the report.
   ScreenshotDataPtr image_ptr;
   if (!screenshot_path.empty() &&  screenshot_source_)
     image_ptr = screenshot_source_->GetCachedScreenshot(screenshot_path);
 
 #if defined(OS_CHROMEOS)
   std::string sys_info_checkbox;
   (*i++)->GetAsString(&sys_info_checkbox);
   bool send_sys_info = (sys_info_checkbox == "true");
@@ skipping 90 matching lines @@
   ChromeURLDataManager::AddDataSource(profile, html_source);
 }
 
 #if defined(OS_CHROMEOS)
 // static
 void FeedbackUI::GetMostRecentScreenshots(
     const FilePath& filepath,
     std::vector<std::string>* saved_screenshots,
     size_t max_saved) {
   std::string pattern =
-      std::string(kScreenshotPrefix) + "*" + kScreenshotSuffix;
+      std::string(ScreenshotSource::kScreenshotPrefix) + "*" +
+                  ScreenshotSource::kScreenshotSuffix;
   file_util::FileEnumerator screenshots(filepath, false,
                                         file_util::FileEnumerator::FILES,
                                         pattern);
   FilePath screenshot = screenshots.Next();
 
   std::vector<std::string> screenshot_filepaths;
   while (!screenshot.empty()) {
     screenshot_filepaths.push_back(screenshot.BaseName().value());
     screenshot = screenshots.Next();
   }
 
   size_t sort_size = std::min(max_saved, screenshot_filepaths.size());
   std::partial_sort(screenshot_filepaths.begin(),
                     screenshot_filepaths.begin() + sort_size,
                     screenshot_filepaths.end(),
                     ScreenshotTimestampComp);
   for (size_t i = 0; i < sort_size; ++i)
-    saved_screenshots->push_back(std::string(kSavedScreenshotsUrl) +
-                                   screenshot_filepaths[i]);
+    saved_screenshots->push_back(
+                    std::string(ScreenshotSource::kScreenshotUrlRoot) +
+                    std::string(ScreenshotSource::kScreenshotSaved) +
+                    screenshot_filepaths[i]);
 }
 #endif