fix build with enable_web_intents=0 on chromeos

chrome/browser/chromeos/extensions/file_browser_private_api.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/extensions/file_browser_private_api.h"
 
 #include <sys/stat.h>
 #include <sys/statvfs.h>
 #include <sys/types.h>
 #include <utime.h>
@@ skipping 246 matching lines @@
   if (icons.empty())
     return result;
   result = icons.rbegin()->second;
   for (InstalledApp::IconList::const_reverse_iterator iter = icons.rbegin();
        iter != icons.rend() && iter->first >= preferred_size; ++iter) {
         result = iter->second;
   }
   return result;
 }
 
+#if defined(ENABLE_WEB_INTENTS)
 // Finds the title of the given Web Intents |action|, if the passed extension
 // supports this action for all specified |mime_types|. Returns true and
 // provides the |title| as output on success.
 bool FindTitleForActionWithTypes(
     const Extension* extension,
     const std::string& action,
     const std::set<std::string>& mime_types,
     std::string* title) {
   DCHECK(!mime_types.empty());
   std::set<std::string> pending(mime_types.begin(), mime_types.end());
@@ skipping 19 matching lines @@
       found_title = UTF16ToUTF8(data->title);
   }
 
   // Not all mime-types have been found.
   if (!pending.empty())
     return false;
 
   *title = found_title;
   return true;
 }
+#endif  // defined(ENABLE_WEB_INTENTS)
 
 // Retrieves total and remaining available size on |mount_path|.
 void GetSizeStatsOnFileThread(const std::string& mount_path,
                               size_t* total_size_kb,
                               size_t* remaining_size_kb) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   uint64_t total_size_in_bytes = 0;
   uint64_t remaining_size_in_bytes = 0;
 
@@ skipping 655 matching lines @@
         task->SetString("iconUrl", kDefaultIcon);
 
       task->SetBoolean("driveApp", false);
       result_list->Append(task);
     }
   }
 
   return true;
 }
 
+#if defined(ENABLE_WEB_INTENTS)
 // Find Web Intent platform apps that support the View task, and add them to
 // the |result_list|. These will be marked as kTaskWebIntent.
 bool GetFileTasksFileBrowserFunction::FindWebIntentTasks(
     const std::vector<FilePath>& file_paths,
     ListValue* result_list) {
   DCHECK(!file_paths.empty());
   ExtensionService* service = profile_->GetExtensionService();
   if (!service)
     return false;
 
@@ skipping 31 matching lines @@
       task->SetString("iconUrl", best_icon.spec());
     else
       task->SetString("iconUrl", kDefaultIcon);
 
     task->SetBoolean("driveApp", false);
     result_list->Append(task);
   }
 
   return true;
 }
+#endif  // defined(ENABLE_WEB_INTENTS)
 
 bool GetFileTasksFileBrowserFunction::RunImpl() {
   // First argument is the list of files to get tasks for.
   ListValue* files_list = NULL;
   if (!args_->GetList(0, &files_list))
     return false;
 
   // Second argument is the list of mime types of each of the files in the list.
   ListValue* mime_types_list = NULL;
   if (!args_->GetList(1, &mime_types_list))
@@ skipping 96 matching lines @@
     result_list->Append(task);
   }
 
   // Take the union of platform app file handlers, Web Intents that platform
   // apps may accept, and all previous Drive and extension tasks. As above, we
   // know there aren't duplicates because they're entirely different kinds of
   // tasks.
   if (!FindAppTasks(file_paths, result_list))
     return false;
 
+#if defined(ENABLE_WEB_INTENTS)
   // TODO(benwells): remove the web intents tasks once we no longer support
   // them.
   if (!FindWebIntentTasks(file_paths, result_list))
     return false;
+#endif
 
   if (VLOG_IS_ON(1)) {
     std::string result_json;
     base::JSONWriter::WriteWithOptions(
         result_list,
         base::JSONWriter::OPTIONS_DO_NOT_ESCAPE |
           base::JSONWriter::OPTIONS_PRETTY_PRINT,
         &result_json);
     VLOG(1) << "GetFileTasks result:\n" << result_json;
   }
@@ skipping 2040 matching lines @@
                  this, name.size()));
   return true;
 }
 
 void ValidatePathNameLengthFunction::OnFilePathLimitRetrieved(
     size_t current_length,
     size_t max_length) {
   SetResult(new base::FundamentalValue(current_length <= max_length));
   SendResponse(true);
 }