Stop setting invalid value to the |tab_id| field of fileBrowserHandler API.

chrome/browser/chromeos/file_manager/file_browser_handlers.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/file_manager/file_browser_handlers.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/i18n/case_conversion.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 144 matching lines @@
 //    files. The event will launch the file browser handler if not active.
 // 4) In the file browser handler, onExecute event is handled and executes the
 //    task in JavaScript.
 //
 // That said, the class itself does not execute a task. The task will be
 // executed in JavaScript.
 class FileBrowserHandlerExecutor {
  public:
   FileBrowserHandlerExecutor(Profile* profile,
                              const Extension* extension,
-                             int32 tab_id,
                              const std::string& action_id);
 
   // Executes the task for each file. |done| will be run with the result.
   void Execute(const std::vector<FileSystemURL>& file_urls,
                const file_tasks::FileTaskFinishedCallback& done);
 
  private:
   // This object is responsible to delete itself.
   virtual ~FileBrowserHandlerExecutor();
 
@@ skipping 25 matching lines @@
 
   // Registers file permissions from |handler_host_permissions_| with
   // ChildProcessSecurityPolicy for process with id |handler_pid|.
   void SetupHandlerHostFileAccessPermissions(
       const FileDefinitionList& file_list,
       const Extension* extension,
       int handler_pid);
 
   Profile* profile_;
   scoped_refptr<const Extension> extension_;
-  int32 tab_id_;
   const std::string action_id_;
   file_tasks::FileTaskFinishedCallback done_;
   base::WeakPtrFactory<FileBrowserHandlerExecutor> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(FileBrowserHandlerExecutor);
 };
 
 FileBrowserHandlerExecutor::FileDefinition::FileDefinition()
     : is_directory(false) {
 }
@@ skipping 48 matching lines @@
     file.is_directory = file_info.is_directory;
     file.absolute_path = local_path;
     file_list.push_back(file);
   }
   return file_list;
 }
 
 FileBrowserHandlerExecutor::FileBrowserHandlerExecutor(
     Profile* profile,
     const Extension* extension,
-    int32 tab_id,
     const std::string& action_id)
     : profile_(profile),
       extension_(extension),
-      tab_id_(tab_id),
       action_id_(action_id),
       weak_ptr_factory_(this) {
 }
 
 FileBrowserHandlerExecutor::~FileBrowserHandlerExecutor() {}
 
 void FileBrowserHandlerExecutor::Execute(
     const std::vector<FileSystemURL>& file_urls,
     const file_tasks::FileTaskFinishedCallback& done) {
   done_ = done;
@@ skipping 102 matching lines @@
     DictionaryValue* file_def = new DictionaryValue();
     file_entries->Append(file_def);
     file_def->SetString("fileSystemName", file_system_name);
     file_def->SetString("fileSystemRoot", file_system_root.spec());
     base::FilePath root(FILE_PATH_LITERAL("/"));
     base::FilePath full_path = root.Append(iter->virtual_path);
     file_def->SetString("fileFullPath", full_path.value());
     file_def->SetBoolean("fileIsDirectory", iter->is_directory);
   }
 
-  details->SetInteger("tab_id", tab_id_);
-
   scoped_ptr<extensions::Event> event(new extensions::Event(
       "fileBrowserHandler.onExecute", event_args.Pass()));
   event->restrict_to_browser_context = profile_;
   event_router->DispatchEventToExtension(extension_->id(), event.Pass());
 
   ExecuteDoneOnUIThread(true);
 }
 
 void FileBrowserHandlerExecutor::SetupHandlerHostFileAccessPermissions(
     const FileDefinitionList& file_list,
@@ skipping 46 matching lines @@
     }
   }
   return num_opened > 0;
 }
 
 }  // namespace
 
 bool ExecuteFileBrowserHandler(
     Profile* profile,
     const Extension* extension,
-    int32 tab_id,
     const std::string& action_id,
     const std::vector<FileSystemURL>& file_urls,
     const file_tasks::FileTaskFinishedCallback& done) {
   // Forbid calling undeclared handlers.
   if (!FindFileBrowserHandlerForActionId(extension, action_id))
     return false;
 
   // Some action IDs of the file manager's file browser handlers require the
   // files to be directly opened with the browser.
   if (ShouldBeOpenedWithBrowser(extension->id(), action_id)) {
     return OpenFilesWithBrowser(profile, file_urls);
   }
 
   // The executor object will be self deleted on completion.
   (new FileBrowserHandlerExecutor(
-      profile, extension, tab_id, action_id))->Execute(file_urls, done);
+      profile, extension, action_id))->Execute(file_urls, done);
   return true;
 }
 
 bool IsFallbackFileBrowserHandler(const file_tasks::TaskDescriptor& task) {
   return (task.task_type == file_tasks::TASK_TYPE_FILE_BROWSER_HANDLER &&
           (task.app_id == kFileManagerAppId ||
            task.app_id == extension_misc::kQuickOfficeComponentExtensionId ||
            task.app_id == extension_misc::kQuickOfficeDevExtensionId ||
            task.app_id == extension_misc::kQuickOfficeExtensionId));
 }
@@ skipping 44 matching lines @@
       common_handlers.erase(gallery_iter);
     else
       common_handlers.erase(watch_iter);
   }
 
   return common_handlers;
 }
 
 }  // namespace file_browser_handlers
 }  // namespace file_manager