[cros] disable GDrive option on certain file pickers

chrome/browser/file_select_helper.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/file_select_helper.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/file_util.h"
@@ skipping 227 matching lines @@
       FilePathListToSelectedFileInfoList(entry->results_);
 
   if (id == kFileSelectEnumerationId)
     NotifyRenderViewHost(entry->rvh_, selected_files, dialog_type_);
   else
     entry->rvh_->DirectoryEnumerationFinished(id, entry->results_);
 
   EnumerateDirectoryEnd();
 }
 
-ui::SelectFileDialog::FileTypeInfo*
+scoped_ptr<ui::SelectFileDialog::FileTypeInfo>
 FileSelectHelper::GetFileTypesFromAcceptType(
     const std::vector<string16>& accept_types) {
+  scoped_ptr<ui::SelectFileDialog::FileTypeInfo> base_file_type(
+      new ui::SelectFileDialog::FileTypeInfo());
+  base_file_type->support_gdata = true;
   if (accept_types.empty())
-    return NULL;
+    return base_file_type.Pass();
 
   // Create FileTypeInfo and pre-allocate for the first extension list.
   scoped_ptr<ui::SelectFileDialog::FileTypeInfo> file_type(
-      new ui::SelectFileDialog::FileTypeInfo());
+      new ui::SelectFileDialog::FileTypeInfo(*base_file_type));
   file_type->include_all_files = true;
   file_type->extensions.resize(1);
   std::vector<FilePath::StringType>* extensions = &file_type->extensions.back();
 
   // Find the corresponding extensions.
   int valid_type_count = 0;
   int description_id = 0;
   for (size_t i = 0; i < accept_types.size(); ++i) {
     std::string ascii_type = UTF16ToASCII(accept_types[i]);
     if (!IsAcceptTypeValid(ascii_type))
@@ skipping 15 matching lines @@
 
       net::GetExtensionsForMimeType(ascii_type, extensions);
     }
 
     if (extensions->size() > old_extension_size)
       valid_type_count++;
   }
 
   // If no valid extension is added, bail out.
   if (valid_type_count == 0)
-    return NULL;
+    return base_file_type.Pass();
 
   // Use a generic description "Custom Files" if either of the following is
   // true:
   // 1) There're multiple types specified, like "audio/*,video/*"
   // 2) There're multiple extensions for a MIME type without parameter, like
   //    "ehtml,shtml,htm,html" for "text/html". On Windows, the select file
   //    dialog uses the first extension in the list to form the description,
   //    like "EHTML Files". This is not what we want.
   if (valid_type_count > 1 ||
       (valid_type_count == 1 && description_id == 0 && extensions->size() > 1))
     description_id = IDS_CUSTOM_FILES;
 
   if (description_id) {
     file_type->extension_description_overrides.push_back(
         l10n_util::GetStringUTF16(description_id));
   }
 
-  return file_type.release();
+  return file_type.Pass();
 }
 
 // static
 void FileSelectHelper::RunFileChooser(content::WebContents* tab,
                                       const FileChooserParams& params) {
   Profile* profile = Profile::FromBrowserContext(tab->GetBrowserContext());
   // FileSelectHelper will keep itself alive until it sends the result message.
   scoped_refptr<FileSelectHelper> file_select_helper(
       new FileSelectHelper(profile));
   file_select_helper->RunFileChooser(tab->GetRenderViewHost(), tab, params);
@@ skipping 33 matching lines @@
   // Because this class returns notifications to the RenderViewHost, it is
   // difficult for callers to know how long to keep a reference to this
   // instance. We AddRef() here to keep the instance alive after we return
   // to the caller, until the last callback is received from the file dialog.
   // At that point, we must call RunFileChooserEnd().
   AddRef();
 }
 
 void FileSelectHelper::RunFileChooserOnFileThread(
     const FileChooserParams& params) {
-  select_file_types_.reset(
-      GetFileTypesFromAcceptType(params.accept_types));
+  select_file_types_ = GetFileTypesFromAcceptType(params.accept_types);
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&FileSelectHelper::RunFileChooserOnUIThread, this, params));
 }
 
 void FileSelectHelper::RunFileChooserOnUIThread(
     const FileChooserParams& params) {
   if (!render_view_host_ || !web_contents_) {
     // If the renderer was destroyed before we started, just cancel the
@@ skipping 29 matching lines @@
       profile_->last_selected_directory().Append(params.default_file_name);
 
   gfx::NativeWindow owning_window =
       platform_util::GetTopLevel(render_view_host_->GetView()->GetNativeView());
 
   select_file_dialog_->SelectFile(
       dialog_type_,
       params.title,
       default_file_name,
       select_file_types_.get(),
-      select_file_types_.get() ? 1 : 0,  // 1-based index.
+      select_file_types_.get() && !select_file_types_->extensions.empty() ?
+          1 : 0,  // 1-based index of default extension to show.
       FILE_PATH_LITERAL(""),
       owning_window,
 #if defined(OS_ANDROID)
       const_cast<content::FileChooserParams*>(&params));
 #else
       NULL);
 #endif
 
   select_file_types_.reset();
 }
@@ skipping 55 matching lines @@
   // A 1 character accept type will always be invalid (either a "." in the case
   // of an extension or a "/" in the case of a MIME type).
   std::string unused;
   if (accept_type.length() <= 1 ||
       StringToLowerASCII(accept_type) != accept_type ||
       TrimWhitespaceASCII(accept_type, TRIM_ALL, &unused) != TRIM_NONE) {
     return false;
   }
   return true;
 }