drive: Rename 'gdata' namespace to 'drive' in chrome/browser/chromeos/drive

chrome/browser/chromeos/drive/drive_webapps_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_webapps_registry.h"
 
 #include <algorithm>
 #include <utility>
 #include <vector>
 
 #include "base/file_path.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "content/public/browser/browser_thread.h"
 #include "chrome/browser/google_apis/drive_api_parser.h"
 
 using content::BrowserThread;
 
-namespace gdata {
+namespace drive {
 
 namespace {
 
 // WebApp store URL prefix.
 const char kStoreProductUrl[] = "https://chrome.google.com/webstore/";
 
 // Extracts Web store id from its web store URL.
 std::string GetWebStoreIdFromUrl(const GURL& url) {
   if (!StartsWithASCII(url.spec(), kStoreProductUrl, false)) {
     LOG(WARNING) << "Unrecognized product URL " << url.spec();
     return std::string();
   }
 
   FilePath path(url.path());
   std::vector<FilePath::StringType> components;
   path.GetComponents(&components);
   DCHECK_LE(2U, components.size());  // Coming from kStoreProductUrl
 
   // Return the last part of the path
   return components[components.size() - 1];
 }
 
 // TODO(kochi): This is duplicate from gdata_wapi_parser.cc.
-bool SortBySize(const InstalledApp::IconList::value_type& a,
-                const InstalledApp::IconList::value_type& b) {
+bool SortBySize(const gdata::InstalledApp::IconList::value_type& a,
+                const gdata::InstalledApp::IconList::value_type& b) {
   return a.first < b.first;
 }
 
 }  // namespace
 
 // DriveWebAppInfo struct implementation.
 
-DriveWebAppInfo::DriveWebAppInfo(const std::string& app_id,
-                                 const InstalledApp::IconList& app_icons,
-                                 const InstalledApp::IconList& document_icons,
-                                 const std::string& web_store_id,
-                                 const string16& app_name,
-                                 const string16& object_type,
-                                 bool is_primary_selector)
+DriveWebAppInfo::DriveWebAppInfo(
+    const std::string& app_id,
+    const gdata::InstalledApp::IconList& app_icons,
+    const gdata::InstalledApp::IconList& document_icons,
+    const std::string& web_store_id,
+    const string16& app_name,
+    const string16& object_type,
+    bool is_primary_selector)
     : app_id(app_id),
       app_icons(app_icons),
       document_icons(document_icons),
       web_store_id(web_store_id),
       app_name(app_name),
       object_type(object_type),
       is_primary_selector(is_primary_selector) {
 }
 
 DriveWebAppInfo::~DriveWebAppInfo() {
 }
 
 // DriveFileSystem::WebAppFileSelector struct implementation.
 
 DriveWebAppsRegistry::WebAppFileSelector::WebAppFileSelector(
     const GURL& product_link,
-    const InstalledApp::IconList& app_icons,
-    const InstalledApp::IconList& document_icons,
+    const gdata::InstalledApp::IconList& app_icons,
+    const gdata::InstalledApp::IconList& document_icons,
     const string16& object_type,
     const std::string& app_id,
     bool is_primary_selector)
     : product_link(product_link),
       app_icons(app_icons),
       document_icons(document_icons),
       object_type(object_type),
       app_id(app_id),
       is_primary_selector(is_primary_selector) {
 }
@@ skipping 50 matching lines @@
   for (WebAppFileSelectorMap::iterator iter = webapp_extension_map_.begin();
       iter != webapp_extension_map_.end(); ++iter) {
     std::string id = GetWebStoreIdFromUrl(iter->second->product_link);
     if (id == web_store_id)
       extensions.insert(iter->first);
   }
   return extensions;
 }
 
 void DriveWebAppsRegistry::UpdateFromFeed(
-    const AccountMetadataFeed& metadata) {
+    const gdata::AccountMetadataFeed& metadata) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   url_to_name_map_.clear();
   STLDeleteValues(&webapp_extension_map_);
   STLDeleteValues(&webapp_mimetypes_map_);
-  for (ScopedVector<InstalledApp>::const_iterator it =
+  for (ScopedVector<gdata::InstalledApp>::const_iterator it =
            metadata.installed_apps().begin();
        it != metadata.installed_apps().end(); ++it) {
-    const InstalledApp& app = **it;
+    const gdata::InstalledApp& app = **it;
     GURL product_url = app.GetProductUrl();
     if (product_url.is_empty())
       continue;
 
-    InstalledApp::IconList app_icons =
-        app.GetIconsForCategory(AppIcon::ICON_APPLICATION);
-    InstalledApp::IconList document_icons =
-        app.GetIconsForCategory(AppIcon::ICON_DOCUMENT);
+    gdata::InstalledApp::IconList app_icons =
+        app.GetIconsForCategory(gdata::AppIcon::ICON_APPLICATION);
+    gdata::InstalledApp::IconList document_icons =
+        app.GetIconsForCategory(gdata::AppIcon::ICON_DOCUMENT);
 
     if (VLOG_IS_ON(1)) {
       std::vector<std::string> mime_types;
       for (size_t i = 0; app.primary_mimetypes().size(); ++i)
         mime_types.push_back(*app.primary_mimetypes()[i]);
       for (size_t i = 0; app.secondary_mimetypes().size(); ++i)
         mime_types.push_back(*app.secondary_mimetypes()[i]);
 
       std::vector<std::string> extensions;
       for (size_t i = 0; app.primary_extensions().size(); ++i)
@@ skipping 37 matching lines @@
                        app_icons,
                        document_icons,
                        app.object_type(),
                        app.app_id(),
                        false,   // primary
                        app.secondary_extensions(),
                        &webapp_extension_map_);
   }
 }
 
-void DriveWebAppsRegistry::UpdateFromApplicationList(const AppList& applist) {
+void DriveWebAppsRegistry::UpdateFromApplicationList(
+    const gdata::AppList& applist) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   url_to_name_map_.clear();
   STLDeleteValues(&webapp_extension_map_);
   STLDeleteValues(&webapp_mimetypes_map_);
   for (size_t i = 0; i < applist.items().size(); ++i) {
-    const AppResource& app = *applist.items()[i];
+    const gdata::AppResource& app = *applist.items()[i];
     if (app.product_url().is_empty())
       continue;
 
-    InstalledApp::IconList app_icons;
-    InstalledApp::IconList document_icons;
+    gdata::InstalledApp::IconList app_icons;
+    gdata::InstalledApp::IconList document_icons;
     for (size_t j = 0; j < app.icons().size(); ++j) {
-      const DriveAppIcon& icon = *app.icons()[j];
+      const gdata::DriveAppIcon& icon = *app.icons()[j];
       if (icon.icon_url().is_empty())
         continue;
-      if (icon.category() == DriveAppIcon::APPLICATION)
+      if (icon.category() == gdata::DriveAppIcon::APPLICATION)
         app_icons.push_back(std::make_pair(icon.icon_side_length(),
                                            icon.icon_url()));
-      if (icon.category() == DriveAppIcon::DOCUMENT)
+      if (icon.category() == gdata::DriveAppIcon::DOCUMENT)
         document_icons.push_back(std::make_pair(icon.icon_side_length(),
                                                 icon.icon_url()));
     }
     std::sort(app_icons.begin(), app_icons.end(), SortBySize);
     std::sort(document_icons.begin(), document_icons.end(), SortBySize);
 
     url_to_name_map_.insert(
         std::make_pair(app.product_url(), UTF8ToUTF16(app.name())));
     AddAppSelectorList(app.product_url(),
                        app_icons,
@@ skipping 26 matching lines @@
                        app.application_id(),
                        false,   // primary
                        app.secondary_file_extensions(),
                        &webapp_extension_map_);
   }
 }
 
 // static.
 void DriveWebAppsRegistry::AddAppSelectorList(
     const GURL& product_link,
-    const InstalledApp::IconList& app_icons,
-    const InstalledApp::IconList& document_icons,
+    const gdata::InstalledApp::IconList& app_icons,
+    const gdata::InstalledApp::IconList& document_icons,
     const string16& object_type,
     const std::string& app_id,
     bool is_primary_selector,
     const ScopedVector<std::string>& selectors,
     WebAppFileSelectorMap* map) {
   for (ScopedVector<std::string>::const_iterator it = selectors.begin();
        it != selectors.end(); ++it) {
     std::string* value = *it;
     map->insert(std::make_pair(
         *value, new WebAppFileSelector(product_link,
@@ skipping 31 matching lines @@
         new DriveWebAppInfo(web_app->app_id,
                             web_app->app_icons,
                             web_app->document_icons,
                             web_store_id,
                             product_iter->second,   // app name.
                             web_app->object_type,
                             web_app->is_primary_selector)));
   }
 }
 
-}  // namespace gdata
+}  // namespace drive