Allow /drive files in "Report Issue" page.

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"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/time.h"
@@ skipping 34 matching lines @@
 #include "grit/locale_settings.h"
 #include "net/base/escape.h"
 #include "ui/base/resource/resource_bundle.h"
 
 #if defined(OS_CHROMEOS)
 #include "ash/shell.h"
 #include "ash/shell_delegate.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
+#include "chrome/browser/chromeos/gdata/gdata_file_system_interface.h"
+#include "chrome/browser/chromeos/gdata/gdata.pb.h"
+#include "chrome/browser/chromeos/gdata/gdata_system_service.h"
+#include "chrome/browser/chromeos/gdata/gdata_util.h"
 #include "chrome/browser/chromeos/login/user_manager.h"
 #include "chrome/browser/chromeos/system/syslogs_provider.h"
 #include "ui/aura/root_window.h"
 #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 kScreenshotPattern[] = "Screenshot *.png";
+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;
 }
 
-void GetSavedScreenshots(std::vector<std::string>* saved_screenshots) {
-  saved_screenshots->clear();
-
-  DownloadPrefs* download_prefs = DownloadPrefs::FromBrowserContext(
-      ash::Shell::GetInstance()->delegate()->GetCurrentBrowserContext());
-  FeedbackUI::GetMostRecentScreenshots(
-      download_prefs->DownloadPath(),
-      saved_screenshots,
-      kMaxSavedScreenshots);
-}
-
 std::string GetUserEmail() {
   chromeos::UserManager* manager = chromeos::UserManager::Get();
   if (!manager)
     return std::string();
   else
     return manager->GetLoggedInUser().display_email();
 }
 
+bool ScreenshotGDataTimestampComp(const gdata::GDataEntryProto& entry1,
+                                  const gdata::GDataEntryProto& entry2) {
+  return entry1.file_info().last_modified() >
+      entry2.file_info().last_modified();
+}
+
+void ReadDirectoryCallback(size_t max_saved,
+                           std::vector<std::string>* saved_screenshots,
+                           base::Closure callback,
+                           gdata::GDataFileError error,
+                           bool hide_hosted_documents,
+                           scoped_ptr<gdata::GDataEntryProtoVector> entries) {
+  if (error != gdata::GDATA_FILE_OK) {
+    callback.Run();
+    return;
+  }
+
+  size_t max_scan = std::min(kMaxNumScanFiles, entries->size());
+  std::vector<gdata::GDataEntryProto> screenshot_entries;
+  for (size_t i = 0; i < max_scan; ++i) {
+    const gdata::GDataEntryProto& entry = (*entries)[i];
+    if (StartsWithASCII(entry.base_name(), kScreenshotPrefix, true) &&
+        EndsWith(entry.base_name(), 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(),
+                    ScreenshotGDataTimestampComp);
+  for (size_t i = 0; i < sort_size; ++i) {
+    const gdata::GDataEntryProto& entry = screenshot_entries[i];
+    saved_screenshots->push_back(
+        std::string(kSavedScreenshotsUrl) + entry.resource_id());
+  }
+  callback.Run();
+}
+
 #else
 
 std::string GetUserEmail() {
   Profile* profile = ProfileManager::GetLastUsedProfile();
   if (!profile)
     return std::string();
 
   SigninManager* signin = SigninManagerFactory::GetForProfile(profile);
   if (!signin)
     return std::string();
@@ skipping 91 matching lines @@
   // WebUIMessageHandler implementation.
   virtual void RegisterMessages() OVERRIDE;
 
  private:
   void HandleGetDialogDefaults(const ListValue* args);
   void HandleRefreshCurrentScreenshot(const ListValue* args);
 #if defined(OS_CHROMEOS)
   void HandleRefreshSavedScreenshots(const ListValue* args);
   void RefreshSavedScreenshotsCallback(
       std::vector<std::string>* saved_screenshots);
+  void GetMostRecentScreenshotsGData(
+      const FilePath& filepath, std::vector<std::string>* saved_screenshots,
+      size_t max_saved, base::Closure callback);
 #endif
   void HandleSendReport(const ListValue* args);
   void HandleCancel(const ListValue* args);
   void HandleOpenSystemTab(const ListValue* args);
 
   void SetupScreenshotsSource();
   void ClobberScreenshotsSource();
 
   void CancelFeedbackCollection();
   void CloseFeedbackTab();
@@ skipping 88 matching lines @@
   }
   // Make sure we don't leave any screenshot data around.
   FeedbackUtil::ClearScreenshotPng();
 }
 
 void FeedbackHandler::ClobberScreenshotsSource() {
   // Re-create our screenshots data source (this clobbers the last source)
   // setting the screenshot to NULL, effectively disabling the source
   // TODO(rkc): Once there is a method to 'remove' a source, change this code
   Profile* profile = Profile::FromBrowserContext(tab_->GetBrowserContext());
-  ChromeURLDataManager::AddDataSource(profile, new ScreenshotSource(NULL));
+  ChromeURLDataManager::AddDataSource(profile,
+                                      new ScreenshotSource(NULL, profile));
 
   FeedbackUtil::ClearScreenshotPng();
 }
 
 void FeedbackHandler::SetupScreenshotsSource() {
+  Profile* profile = Profile::FromBrowserContext(tab_->GetBrowserContext());
   // If we don't already have a screenshot source object created, create one.
   if (!screenshot_source_) {
     screenshot_source_ =
-        new ScreenshotSource(FeedbackUtil::GetScreenshotPng());
+        new ScreenshotSource(FeedbackUtil::GetScreenshotPng(), profile);
   }
   // Add the source to the data manager.
-  Profile* profile = Profile::FromBrowserContext(tab_->GetBrowserContext());
   ChromeURLDataManager::AddDataSource(profile, screenshot_source_);
 }
 
 bool FeedbackHandler::Init() {
   std::string page_url;
   if (tab_->GetController().GetActiveEntry()) {
      page_url = tab_->GetController().GetActiveEntry()->GetURL().spec();
   }
 
   url_parse::Parsed parts;
@@ skipping 146 matching lines @@
 
 void FeedbackHandler::HandleRefreshCurrentScreenshot(const ListValue*) {
   std::string current_screenshot(kCurrentScreenshotUrl);
   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>;
-  BrowserThread::PostTaskAndReply(
-      BrowserThread::FILE, FROM_HERE,
-      base::Bind(&GetSavedScreenshots, base::Unretained(saved_screenshots)),
-      base::Bind(&FeedbackHandler::RefreshSavedScreenshotsCallback,
-                 base::Unretained(this), base::Owned(saved_screenshots)));
+  FilePath filepath = DownloadPrefs::FromBrowserContext(
+      tab_->GetBrowserContext())->DownloadPath();
+  base::Closure refresh_callback = base::Bind(
+      &FeedbackHandler::RefreshSavedScreenshotsCallback,
+      AsWeakPtr(), base::Owned(saved_screenshots));
+  if (gdata::util::IsUnderGDataMountPoint(filepath)) {
+    GetMostRecentScreenshotsGData(
+        filepath, saved_screenshots, kMaxSavedScreenshots, refresh_callback);
+  } else {
+    BrowserThread::PostTaskAndReply(
+        BrowserThread::FILE, FROM_HERE,
+        base::Bind(&FeedbackUI::GetMostRecentScreenshots, filepath,
+                   base::Unretained(saved_screenshots), kMaxSavedScreenshots),
+        refresh_callback);
+  }
 }
 
 void FeedbackHandler::RefreshSavedScreenshotsCallback(
     std::vector<std::string>* saved_screenshots) {
   ListValue screenshots_list;
   for (size_t i = 0; i < saved_screenshots->size(); ++i)
     screenshots_list.Append(new StringValue((*saved_screenshots)[i]));
   web_ui()->CallJavascriptFunction("setupSavedScreenshots", screenshots_list);
 }
 
+void FeedbackHandler::GetMostRecentScreenshotsGData(
+    const FilePath& filepath, std::vector<std::string>* saved_screenshots,
+    size_t max_saved, base::Closure callback) {
+  gdata::GDataFileSystemInterface* file_system =
+      gdata::GDataSystemServiceFactory::GetForProfile(
+          Profile::FromWebUI(web_ui()))->file_system();
+  file_system->ReadDirectoryByPath(
+      gdata::util::ExtractGDataPath(filepath),
+      base::Bind(&ReadDirectoryCallback, max_saved, saved_screenshots,
+                 callback));
+}
 #endif
 
 
 void FeedbackHandler::HandleSendReport(const ListValue* list_value) {
   if (!feedback_data_) {
     LOG(ERROR) << "Bug report hasn't been intialized yet.";
     return;
   }
   // TODO(rkc): Find a better way to do this check.
 #if defined(OS_CHROMEOS)
@@ skipping 119 matching lines @@
   Profile* profile = Profile::FromWebUI(web_ui);
   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;
   file_util::FileEnumerator screenshots(filepath, false,
                                         file_util::FileEnumerator::FILES,
-                                        std::string(kScreenshotPattern));
+                                        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]);
 }
 #endif