Less dependency for DriveAppRegistry.

chrome/browser/chromeos/drive/drive_app_registry.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/chromeos/drive/drive_app_registry.h"
 
 #include <algorithm>
-#include <string>
+#include <set>
 #include <utility>
-#include <vector>
 
 #include "base/files/file_path.h"
-#include "base/strings/string_util.h"
-#include "chrome/browser/chromeos/drive/file_system_util.h"
-#include "chrome/browser/chromeos/drive/job_scheduler.h"
+#include "chrome/browser/drive/drive_service_interface.h"
 #include "content/public/browser/browser_thread.h"
 #include "google_apis/drive/drive_api_parser.h"
 
 using content::BrowserThread;
 
 namespace {
 
 // Add {selector -> app_id} mapping to |map|.
 void AddAppSelectorList(const ScopedVector<std::string>& selectors,
                         const std::string& app_id,
@@ skipping 28 matching lines @@
     : app_id(app_id),
       app_icons(app_icons),
       document_icons(document_icons),
       app_name(app_name),
       create_url(create_url) {
 }
 
 DriveAppInfo::~DriveAppInfo() {
 }
 
-DriveAppRegistry::DriveAppRegistry(JobScheduler* scheduler)
-    : scheduler_(scheduler),
+DriveAppRegistry::DriveAppRegistry(DriveServiceInterface* drive_service)
+    : drive_service_(drive_service),
       is_updating_(false),
       weak_ptr_factory_(this) {
 }
 
 DriveAppRegistry::~DriveAppRegistry() {
 }
 
 void DriveAppRegistry::GetAppsForFile(
     const base::FilePath::StringType& file_extension,
     const std::string& mime_type,
-    ScopedVector<DriveAppInfo>* apps) const {
+    std::vector<DriveAppInfo>* apps) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   std::vector<std::string> matched_apps;
   if (!file_extension.empty()) {
     const base::FilePath::StringType without_dot = file_extension.substr(1);
     FindAppsForSelector(without_dot, extension_map_, &matched_apps);
   }
   if (!mime_type.empty())
     FindAppsForSelector(mime_type, mimetype_map_, &matched_apps);
 
   // Insert found Drive apps into |apps|, but skip duplicate results.
   std::set<std::string> inserted_app_ids;
   for (size_t i = 0; i < matched_apps.size(); ++i) {
     if (inserted_app_ids.count(matched_apps[i]) == 0) {
       inserted_app_ids.insert(matched_apps[i]);
       std::map<std::string, DriveAppInfo>::const_iterator it =
           all_apps_.find(matched_apps[i]);
       DCHECK(it != all_apps_.end());
-      apps->push_back(new DriveAppInfo(it->second));
+      apps->push_back(it->second);
     }
   }
 }
 
 void DriveAppRegistry::Update() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (is_updating_)  // There is already an update in progress.
     return;
   is_updating_ = true;
 
-  scheduler_->GetAppList(base::Bind(&DriveAppRegistry::UpdateAfterGetAppList,
-                                    weak_ptr_factory_.GetWeakPtr()));
+  drive_service_->GetAppList(
+      base::Bind(&DriveAppRegistry::UpdateAfterGetAppList,
+                 weak_ptr_factory_.GetWeakPtr()));
 }
 
 void DriveAppRegistry::UpdateAfterGetAppList(
     google_apis::GDataErrorCode gdata_error,
     scoped_ptr<google_apis::AppList> app_list) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DCHECK(is_updating_);
   is_updating_ = false;
 
-  FileError error = GDataToFileError(gdata_error);
-  if (error != FILE_ERROR_OK) {
-    // Failed to fetch the data from the server. We can do nothing here.
+  // Failed to fetch the data from the server. We can do nothing here.
+  if (gdata_error != google_apis::HTTP_SUCCESS)
     return;
-  }
 
   DCHECK(app_list);
   UpdateFromAppList(*app_list);
 }
 
 void DriveAppRegistry::UpdateFromAppList(const google_apis::AppList& app_list) {
   all_apps_.clear();
   extension_map_.clear();
   mimetype_map_.clear();
 
@@ skipping 41 matching lines @@
 
   // Go forward while the size is larger or equal to preferred_size.
   size_t i = 1;
   while (i < sorted_icons.size() && sorted_icons[i].first >= preferred_size)
     ++i;
   return sorted_icons[i - 1].second;
 }
 
 }  // namespace util
 }  // namespace drive