chrome/browser/media_galleries/linux/mtp_device_delegate_impl_linux.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/media_galleries/linux/mtp_device_delegate_impl_linux.h"
   6
   7 #include <algorithm>
   8 #include <vector>
   9
  10 #include "base/bind.h"
  11 #include "base/numerics/safe_conversions.h"
  12 #include "base/strings/string_number_conversions.h"
  13 #include "base/strings/string_split.h"
  14 #include "base/strings/string_util.h"
  15 #include "chrome/browser/media_galleries/linux/mtp_device_task_helper.h"
  16 #include "chrome/browser/media_galleries/linux/mtp_device_task_helper_map_service.h"
  17 #include "chrome/browser/media_galleries/linux/snapshot_file_details.h"
  18 #include "net/base/io_buffer.h"
  19 #include "third_party/cros_system_api/dbus/service_constants.h"
  20
  21 namespace {
  22
  23 // File path separator constant.
  24 const char kRootPath[] = "/";
  25
  26 // Returns the device relative file path given |file_path|.
  27 // E.g.: If the |file_path| is "/usb:2,2:12345/DCIM" and |registered_dev_path|
  28 // is "/usb:2,2:12345", this function returns the device relative path which is
  29 // "DCIM".
  30 // In the special case when |registered_dev_path| and |file_path| are the same,
  31 // return |kRootPath|.
  32 std::string GetDeviceRelativePath(const base::FilePath& registered_dev_path,
  33                                   const base::FilePath& file_path) {
  34   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
  35   DCHECK(!registered_dev_path.empty());
  36   DCHECK(!file_path.empty());
  37   std::string result;
  38   if (registered_dev_path == file_path) {
  39     result = kRootPath;
  40   } else {
  41     base::FilePath relative_path;
  42     if (registered_dev_path.AppendRelativePath(file_path, &relative_path)) {
  43       DCHECK(!relative_path.empty());
  44       result = relative_path.value();
  45     }
  46   }
  47   return result;
  48 }
  49
  50 // Returns the MTPDeviceTaskHelper object associated with the MTP device
  51 // storage.
  52 //
  53 // |storage_name| specifies the name of the storage device.
  54 // Returns NULL if the |storage_name| is no longer valid (e.g. because the
  55 // corresponding storage device is detached, etc).
  56 MTPDeviceTaskHelper* GetDeviceTaskHelperForStorage(
  57     const std::string& storage_name) {
  58   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
  59   return MTPDeviceTaskHelperMapService::GetInstance()->GetDeviceTaskHelper(
  60       storage_name);
  61 }
  62
  63 // Opens the storage device for communication.
  64 //
  65 // Called on the UI thread to dispatch the request to the
  66 // MediaTransferProtocolManager.
  67 //
  68 // |storage_name| specifies the name of the storage device.
  69 // |reply_callback| is called when the OpenStorage request completes.
  70 // |reply_callback| runs on the IO thread.
  71 void OpenStorageOnUIThread(
  72     const std::string& storage_name,
  73     const MTPDeviceTaskHelper::OpenStorageCallback& reply_callback) {
  74   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
  75   MTPDeviceTaskHelper* task_helper =
  76       GetDeviceTaskHelperForStorage(storage_name);
  77   if (!task_helper) {
  78     task_helper =
  79         MTPDeviceTaskHelperMapService::GetInstance()->CreateDeviceTaskHelper(
  80             storage_name);
  81   }
  82   task_helper->OpenStorage(storage_name, reply_callback);
  83 }
  84
  85 // Enumerates the |dir_id| directory file entries.
  86 //
  87 // Called on the UI thread to dispatch the request to the
  88 // MediaTransferProtocolManager.
  89 //
  90 // |storage_name| specifies the name of the storage device.
  91 // |success_callback| is called when the ReadDirectory request succeeds.
  92 // |error_callback| is called when the ReadDirectory request fails.
  93 // |success_callback| and |error_callback| runs on the IO thread.
  94 void ReadDirectoryOnUIThread(
  95     const std::string& storage_name,
  96     uint32 dir_id,
  97     const MTPDeviceTaskHelper::ReadDirectorySuccessCallback& success_callback,
  98     const MTPDeviceTaskHelper::ErrorCallback& error_callback) {
  99   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 100   MTPDeviceTaskHelper* task_helper =
 101       GetDeviceTaskHelperForStorage(storage_name);
 102   if (!task_helper)
 103     return;
 104   task_helper->ReadDirectory(dir_id, success_callback, error_callback);
 105 }
 106
 107 // Gets the |file_path| details.
 108 //
 109 // Called on the UI thread to dispatch the request to the
 110 // MediaTransferProtocolManager.
 111 //
 112 // |storage_name| specifies the name of the storage device.
 113 // |success_callback| is called when the GetFileInfo request succeeds.
 114 // |error_callback| is called when the GetFileInfo request fails.
 115 // |success_callback| and |error_callback| runs on the IO thread.
 116 void GetFileInfoOnUIThread(
 117     const std::string& storage_name,
 118     uint32 file_id,
 119     const MTPDeviceTaskHelper::GetFileInfoSuccessCallback& success_callback,
 120     const MTPDeviceTaskHelper::ErrorCallback& error_callback) {
 121   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 122   MTPDeviceTaskHelper* task_helper =
 123       GetDeviceTaskHelperForStorage(storage_name);
 124   if (!task_helper)
 125     return;
 126   task_helper->GetFileInfo(file_id, success_callback, error_callback);
 127 }
 128
 129 // Copies the contents of |device_file_path| to |snapshot_file_path|.
 130 //
 131 // Called on the UI thread to dispatch the request to the
 132 // MediaTransferProtocolManager.
 133 //
 134 // |storage_name| specifies the name of the storage device.
 135 // |device_file_path| specifies the media device file path.
 136 // |snapshot_file_path| specifies the platform path of the snapshot file.
 137 // |file_size| specifies the number of bytes that will be written to the
 138 // snapshot file.
 139 // |success_callback| is called when the copy operation succeeds.
 140 // |error_callback| is called when the copy operation fails.
 141 // |success_callback| and |error_callback| runs on the IO thread.
 142 void WriteDataIntoSnapshotFileOnUIThread(
 143     const std::string& storage_name,
 144     const SnapshotRequestInfo& request_info,
 145     const base::File::Info& snapshot_file_info) {
 146   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 147   MTPDeviceTaskHelper* task_helper =
 148       GetDeviceTaskHelperForStorage(storage_name);
 149   if (!task_helper)
 150     return;
 151   task_helper->WriteDataIntoSnapshotFile(request_info, snapshot_file_info);
 152 }
 153
 154 // Copies the contents of |device_file_path| to |snapshot_file_path|.
 155 //
 156 // Called on the UI thread to dispatch the request to the
 157 // MediaTransferProtocolManager.
 158 //
 159 // |storage_name| specifies the name of the storage device.
 160 // |request| is a struct containing details about the byte read request.
 161 void ReadBytesOnUIThread(
 162     const std::string& storage_name,
 163     const MTPDeviceAsyncDelegate::ReadBytesRequest& request) {
 164   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 165   MTPDeviceTaskHelper* task_helper =
 166       GetDeviceTaskHelperForStorage(storage_name);
 167   if (!task_helper)
 168     return;
 169   task_helper->ReadBytes(request);
 170 }
 171
 172 // Closes the device storage specified by the |storage_name| and destroys the
 173 // MTPDeviceTaskHelper object associated with the device storage.
 174 //
 175 // Called on the UI thread to dispatch the request to the
 176 // MediaTransferProtocolManager.
 177 void CloseStorageAndDestroyTaskHelperOnUIThread(
 178     const std::string& storage_name) {
 179   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 180   MTPDeviceTaskHelper* task_helper =
 181       GetDeviceTaskHelperForStorage(storage_name);
 182   if (!task_helper)
 183     return;
 184   task_helper->CloseStorage();
 185   MTPDeviceTaskHelperMapService::GetInstance()->DestroyDeviceTaskHelper(
 186       storage_name);
 187 }
 188
 189 }  // namespace
 190
 191 MTPDeviceDelegateImplLinux::PendingTaskInfo::PendingTaskInfo(
 192     const base::FilePath& path,
 193     content::BrowserThread::ID thread_id,
 194     const tracked_objects::Location& location,
 195     const base::Closure& task)
 196     : path(path),
 197       thread_id(thread_id),
 198       location(location),
 199       task(task) {
 200 }
 201
 202 MTPDeviceDelegateImplLinux::PendingTaskInfo::~PendingTaskInfo() {
 203 }
 204
 205 // Represents a file on the MTP device.
 206 // Lives on the IO thread.
 207 class MTPDeviceDelegateImplLinux::MTPFileNode {
 208  public:
 209   MTPFileNode(uint32 file_id,
 210               const std::string& file_name,
 211               MTPFileNode* parent,
 212               FileIdToMTPFileNodeMap* file_id_to_node_map);
 213   ~MTPFileNode();
 214
 215   const MTPFileNode* GetChild(const std::string& name) const;
 216
 217   void EnsureChildExists(const std::string& name, uint32 id);
 218
 219   // Clears all the children, except those in |children_to_keep|.
 220   void ClearNonexistentChildren(
 221       const std::set<std::string>& children_to_keep);
 222
 223   bool DeleteChild(uint32 file_id);
 224
 225   uint32 file_id() const { return file_id_; }
 226   const std::string& file_name() const { return file_name_; }
 227   MTPFileNode* parent() { return parent_; }
 228
 229  private:
 230   // Container for holding a node's children.
 231   typedef base::ScopedPtrHashMap<std::string, MTPFileNode> ChildNodes;
 232
 233   const uint32 file_id_;
 234   const std::string file_name_;
 235
 236   ChildNodes children_;
 237   MTPFileNode* const parent_;
 238   FileIdToMTPFileNodeMap* file_id_to_node_map_;
 239
 240   DISALLOW_COPY_AND_ASSIGN(MTPFileNode);
 241 };
 242
 243 MTPDeviceDelegateImplLinux::MTPFileNode::MTPFileNode(
 244     uint32 file_id,
 245     const std::string& file_name,
 246     MTPFileNode* parent,
 247     FileIdToMTPFileNodeMap* file_id_to_node_map)
 248     : file_id_(file_id),
 249       file_name_(file_name),
 250       parent_(parent),
 251       file_id_to_node_map_(file_id_to_node_map) {
 252   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 253   DCHECK(file_id_to_node_map_);
 254   DCHECK(!ContainsKey(*file_id_to_node_map_, file_id_));
 255   (*file_id_to_node_map_)[file_id_] = this;
 256 }
 257
 258 MTPDeviceDelegateImplLinux::MTPFileNode::~MTPFileNode() {
 259   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 260   size_t erased = file_id_to_node_map_->erase(file_id_);
 261   DCHECK_EQ(1U, erased);
 262 }
 263
 264 const MTPDeviceDelegateImplLinux::MTPFileNode*
 265 MTPDeviceDelegateImplLinux::MTPFileNode::GetChild(
 266     const std::string& name) const {
 267   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 268   return children_.get(name);
 269 }
 270
 271 void MTPDeviceDelegateImplLinux::MTPFileNode::EnsureChildExists(
 272     const std::string& name,
 273     uint32 id) {
 274   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 275   const MTPFileNode* child = GetChild(name);
 276   if (child && child->file_id() == id)
 277     return;
 278
 279   children_.set(
 280       name,
 281       make_scoped_ptr(new MTPFileNode(id, name, this, file_id_to_node_map_)));
 282 }
 283
 284 void MTPDeviceDelegateImplLinux::MTPFileNode::ClearNonexistentChildren(
 285     const std::set<std::string>& children_to_keep) {
 286   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 287   std::set<std::string> children_to_erase;
 288   for (ChildNodes::const_iterator it = children_.begin();
 289        it != children_.end(); ++it) {
 290     if (ContainsKey(children_to_keep, it->first))
 291       continue;
 292     children_to_erase.insert(it->first);
 293   }
 294   for (std::set<std::string>::iterator it = children_to_erase.begin();
 295        it != children_to_erase.end(); ++it) {
 296     children_.take_and_erase(*it);
 297   }
 298 }
 299
 300 bool MTPDeviceDelegateImplLinux::MTPFileNode::DeleteChild(uint32 file_id) {
 301   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 302   for (ChildNodes::iterator it = children_.begin();
 303        it != children_.end(); ++it) {
 304     if (it->second->file_id() == file_id) {
 305       children_.erase(it);
 306       return true;
 307     }
 308   }
 309   return false;
 310 }
 311
 312 MTPDeviceDelegateImplLinux::MTPDeviceDelegateImplLinux(
 313     const std::string& device_location)
 314     : init_state_(UNINITIALIZED),
 315       task_in_progress_(false),
 316       device_path_(device_location),
 317       root_node_(new MTPFileNode(mtpd::kRootFileId,
 318                                  "",    // Root node has no name.
 319                                  NULL,  // And no parent node.
 320                                  &file_id_to_node_map_)),
 321       weak_ptr_factory_(this) {
 322   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 323   DCHECK(!device_path_.empty());
 324   base::RemoveChars(device_location, kRootPath, &storage_name_);
 325   DCHECK(!storage_name_.empty());
 326 }
 327
 328 MTPDeviceDelegateImplLinux::~MTPDeviceDelegateImplLinux() {
 329   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 330 }
 331
 332 void MTPDeviceDelegateImplLinux::GetFileInfo(
 333     const base::FilePath& file_path,
 334     const GetFileInfoSuccessCallback& success_callback,
 335     const ErrorCallback& error_callback) {
 336   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 337   DCHECK(!file_path.empty());
 338
 339   // If a ReadDirectory operation is in progress, the file info may already be
 340   // cached.
 341   FileInfoCache::const_iterator it = file_info_cache_.find(file_path);
 342   if (it != file_info_cache_.end()) {
 343     // TODO(thestig): This code is repeated in several places. Combine them.
 344     // e.g. c/b/media_galleries/win/mtp_device_operations_util.cc
 345     const storage::DirectoryEntry& cached_file_entry = it->second;
 346     base::File::Info info;
 347     info.size = cached_file_entry.size;
 348     info.is_directory = cached_file_entry.is_directory;
 349     info.is_symbolic_link = false;
 350     info.last_modified = cached_file_entry.last_modified_time;
 351     info.creation_time = base::Time();
 352
 353     success_callback.Run(info);
 354     return;
 355   }
 356   base::Closure closure =
 357       base::Bind(&MTPDeviceDelegateImplLinux::GetFileInfoInternal,
 358                  weak_ptr_factory_.GetWeakPtr(),
 359                  file_path,
 360                  success_callback,
 361                  error_callback);
 362   EnsureInitAndRunTask(PendingTaskInfo(file_path,
 363                                        content::BrowserThread::IO,
 364                                        FROM_HERE,
 365                                        closure));
 366 }
 367
 368 void MTPDeviceDelegateImplLinux::ReadDirectory(
 369     const base::FilePath& root,
 370     const ReadDirectorySuccessCallback& success_callback,
 371     const ErrorCallback& error_callback) {
 372   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 373   DCHECK(!root.empty());
 374   base::Closure closure =
 375       base::Bind(&MTPDeviceDelegateImplLinux::ReadDirectoryInternal,
 376                  weak_ptr_factory_.GetWeakPtr(),
 377                  root,
 378                  success_callback,
 379                  error_callback);
 380   EnsureInitAndRunTask(PendingTaskInfo(root,
 381                                        content::BrowserThread::IO,
 382                                        FROM_HERE,
 383                                        closure));
 384 }
 385
 386 void MTPDeviceDelegateImplLinux::CreateSnapshotFile(
 387     const base::FilePath& device_file_path,
 388     const base::FilePath& local_path,
 389     const CreateSnapshotFileSuccessCallback& success_callback,
 390     const ErrorCallback& error_callback) {
 391   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 392   DCHECK(!device_file_path.empty());
 393   DCHECK(!local_path.empty());
 394   base::Closure closure =
 395       base::Bind(&MTPDeviceDelegateImplLinux::CreateSnapshotFileInternal,
 396                  weak_ptr_factory_.GetWeakPtr(),
 397                  device_file_path,
 398                  local_path,
 399                  success_callback,
 400                  error_callback);
 401   EnsureInitAndRunTask(PendingTaskInfo(device_file_path,
 402                                        content::BrowserThread::IO,
 403                                        FROM_HERE,
 404                                        closure));
 405 }
 406
 407 bool MTPDeviceDelegateImplLinux::IsStreaming() {
 408   return true;
 409 }
 410
 411 void MTPDeviceDelegateImplLinux::ReadBytes(
 412     const base::FilePath& device_file_path,
 413     const scoped_refptr<net::IOBuffer>& buf,
 414     int64 offset,
 415     int buf_len,
 416     const ReadBytesSuccessCallback& success_callback,
 417     const ErrorCallback& error_callback) {
 418   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 419   DCHECK(!device_file_path.empty());
 420   base::Closure closure =
 421       base::Bind(&MTPDeviceDelegateImplLinux::ReadBytesInternal,
 422                  weak_ptr_factory_.GetWeakPtr(),
 423                  device_file_path,
 424                  buf,
 425                  offset,
 426                  buf_len,
 427                  success_callback,
 428                  error_callback);
 429   EnsureInitAndRunTask(PendingTaskInfo(device_file_path,
 430                                        content::BrowserThread::IO,
 431                                        FROM_HERE,
 432                                        closure));
 433 }
 434
 435 void MTPDeviceDelegateImplLinux::CancelPendingTasksAndDeleteDelegate() {
 436   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 437   // To cancel all the pending tasks, destroy the MTPDeviceTaskHelper object.
 438   content::BrowserThread::PostTask(
 439       content::BrowserThread::UI,
 440       FROM_HERE,
 441       base::Bind(&CloseStorageAndDestroyTaskHelperOnUIThread, storage_name_));
 442   delete this;
 443 }
 444
 445 void MTPDeviceDelegateImplLinux::GetFileInfoInternal(
 446     const base::FilePath& file_path,
 447     const GetFileInfoSuccessCallback& success_callback,
 448     const ErrorCallback& error_callback) {
 449   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 450
 451   uint32 file_id;
 452   if (CachedPathToId(file_path, &file_id)) {
 453     GetFileInfoSuccessCallback success_callback_wrapper =
 454         base::Bind(&MTPDeviceDelegateImplLinux::OnDidGetFileInfo,
 455                    weak_ptr_factory_.GetWeakPtr(),
 456                    success_callback);
 457     ErrorCallback error_callback_wrapper =
 458         base::Bind(&MTPDeviceDelegateImplLinux::HandleDeviceFileError,
 459                    weak_ptr_factory_.GetWeakPtr(),
 460                    error_callback,
 461                    file_id);
 462
 463
 464     base::Closure closure = base::Bind(&GetFileInfoOnUIThread,
 465                                        storage_name_,
 466                                        file_id,
 467                                        success_callback_wrapper,
 468                                        error_callback_wrapper);
 469     EnsureInitAndRunTask(PendingTaskInfo(base::FilePath(),
 470                                          content::BrowserThread::UI,
 471                                          FROM_HERE,
 472                                          closure));
 473   } else {
 474     error_callback.Run(base::File::FILE_ERROR_NOT_FOUND);
 475   }
 476   PendingRequestDone();
 477 }
 478
 479 void MTPDeviceDelegateImplLinux::ReadDirectoryInternal(
 480     const base::FilePath& root,
 481     const ReadDirectorySuccessCallback& success_callback,
 482     const ErrorCallback& error_callback) {
 483   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 484
 485   uint32 dir_id;
 486   if (CachedPathToId(root, &dir_id)) {
 487     GetFileInfoSuccessCallback success_callback_wrapper =
 488         base::Bind(&MTPDeviceDelegateImplLinux::OnDidGetFileInfoToReadDirectory,
 489                    weak_ptr_factory_.GetWeakPtr(),
 490                    dir_id,
 491                    success_callback,
 492                    error_callback);
 493     ErrorCallback error_callback_wrapper =
 494         base::Bind(&MTPDeviceDelegateImplLinux::HandleDeviceFileError,
 495                    weak_ptr_factory_.GetWeakPtr(),
 496                    error_callback,
 497                    dir_id);
 498     base::Closure closure = base::Bind(&GetFileInfoOnUIThread,
 499                                        storage_name_,
 500                                        dir_id,
 501                                        success_callback_wrapper,
 502                                        error_callback_wrapper);
 503     EnsureInitAndRunTask(PendingTaskInfo(base::FilePath(),
 504                                          content::BrowserThread::UI,
 505                                          FROM_HERE,
 506                                          closure));
 507   } else {
 508     error_callback.Run(base::File::FILE_ERROR_NOT_FOUND);
 509   }
 510   PendingRequestDone();
 511 }
 512
 513 void MTPDeviceDelegateImplLinux::CreateSnapshotFileInternal(
 514     const base::FilePath& device_file_path,
 515     const base::FilePath& local_path,
 516     const CreateSnapshotFileSuccessCallback& success_callback,
 517     const ErrorCallback& error_callback) {
 518   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 519
 520   uint32 file_id;
 521   if (CachedPathToId(device_file_path, &file_id)) {
 522     scoped_ptr<SnapshotRequestInfo> request_info(
 523         new SnapshotRequestInfo(file_id,
 524                                 local_path,
 525                                 success_callback,
 526                                 error_callback));
 527     GetFileInfoSuccessCallback success_callback_wrapper =
 528         base::Bind(
 529             &MTPDeviceDelegateImplLinux::OnDidGetFileInfoToCreateSnapshotFile,
 530             weak_ptr_factory_.GetWeakPtr(),
 531             base::Passed(&request_info));
 532     ErrorCallback error_callback_wrapper =
 533         base::Bind(&MTPDeviceDelegateImplLinux::HandleDeviceFileError,
 534                    weak_ptr_factory_.GetWeakPtr(),
 535                    error_callback,
 536                    file_id);
 537     base::Closure closure = base::Bind(&GetFileInfoOnUIThread,
 538                                        storage_name_,
 539                                        file_id,
 540                                        success_callback_wrapper,
 541                                        error_callback_wrapper);
 542     EnsureInitAndRunTask(PendingTaskInfo(base::FilePath(),
 543                                          content::BrowserThread::UI,
 544                                          FROM_HERE,
 545                                          closure));
 546   } else {
 547     error_callback.Run(base::File::FILE_ERROR_NOT_FOUND);
 548   }
 549   PendingRequestDone();
 550 }
 551
 552 void MTPDeviceDelegateImplLinux::ReadBytesInternal(
 553     const base::FilePath& device_file_path,
 554     net::IOBuffer* buf, int64 offset, int buf_len,
 555     const ReadBytesSuccessCallback& success_callback,
 556     const ErrorCallback& error_callback) {
 557   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 558
 559   uint32 file_id;
 560   if (CachedPathToId(device_file_path, &file_id)) {
 561     ReadBytesRequest request(
 562         file_id, buf, offset, buf_len,
 563         base::Bind(&MTPDeviceDelegateImplLinux::OnDidReadBytes,
 564                    weak_ptr_factory_.GetWeakPtr(),
 565                    success_callback),
 566         base::Bind(&MTPDeviceDelegateImplLinux::HandleDeviceFileError,
 567                    weak_ptr_factory_.GetWeakPtr(),
 568                    error_callback,
 569                    file_id));
 570
 571     base::Closure closure =
 572         base::Bind(base::Bind(&ReadBytesOnUIThread, storage_name_, request));
 573     EnsureInitAndRunTask(PendingTaskInfo(base::FilePath(),
 574                                          content::BrowserThread::UI,
 575                                          FROM_HERE,
 576                                          closure));
 577   } else {
 578     error_callback.Run(base::File::FILE_ERROR_NOT_FOUND);
 579   }
 580   PendingRequestDone();
 581 }
 582
 583 void MTPDeviceDelegateImplLinux::EnsureInitAndRunTask(
 584     const PendingTaskInfo& task_info) {
 585   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 586   if ((init_state_ == INITIALIZED) && !task_in_progress_) {
 587     RunTask(task_info);
 588     return;
 589   }
 590
 591   // Only *Internal functions have empty paths. Since they are the continuation
 592   // of the current running task, they get to cut in line.
 593   if (task_info.path.empty())
 594     pending_tasks_.push_front(task_info);
 595   else
 596     pending_tasks_.push_back(task_info);
 597
 598   if (init_state_ == UNINITIALIZED) {
 599     init_state_ = PENDING_INIT;
 600     task_in_progress_ = true;
 601     content::BrowserThread::PostTask(
 602         content::BrowserThread::UI,
 603         FROM_HERE,
 604         base::Bind(&OpenStorageOnUIThread,
 605                    storage_name_,
 606                    base::Bind(&MTPDeviceDelegateImplLinux::OnInitCompleted,
 607                               weak_ptr_factory_.GetWeakPtr())));
 608   }
 609 }
 610
 611 void MTPDeviceDelegateImplLinux::RunTask(const PendingTaskInfo& task_info) {
 612   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 613   DCHECK_EQ(INITIALIZED, init_state_);
 614   DCHECK(!task_in_progress_);
 615   task_in_progress_ = true;
 616
 617   bool need_to_check_cache = !task_info.path.empty();
 618   if (need_to_check_cache) {
 619     base::FilePath uncached_path =
 620         NextUncachedPathComponent(task_info.path, task_info.cached_path);
 621     if (!uncached_path.empty()) {
 622       // Save the current task and do a cache lookup first.
 623       pending_tasks_.push_front(task_info);
 624       FillFileCache(uncached_path);
 625       return;
 626     }
 627   }
 628
 629   content::BrowserThread::PostTask(task_info.thread_id,
 630                           task_info.location,
 631                           task_info.task);
 632 }
 633
 634 void MTPDeviceDelegateImplLinux::WriteDataIntoSnapshotFile(
 635     const base::File::Info& file_info) {
 636   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 637   DCHECK(current_snapshot_request_info_.get());
 638   DCHECK_GT(file_info.size, 0);
 639   DCHECK(task_in_progress_);
 640   SnapshotRequestInfo request_info(
 641       current_snapshot_request_info_->file_id,
 642       current_snapshot_request_info_->snapshot_file_path,
 643       base::Bind(
 644           &MTPDeviceDelegateImplLinux::OnDidWriteDataIntoSnapshotFile,
 645           weak_ptr_factory_.GetWeakPtr()),
 646       base::Bind(
 647           &MTPDeviceDelegateImplLinux::OnWriteDataIntoSnapshotFileError,
 648           weak_ptr_factory_.GetWeakPtr()));
 649
 650   base::Closure task_closure = base::Bind(&WriteDataIntoSnapshotFileOnUIThread,
 651                                           storage_name_,
 652                                           request_info,
 653                                           file_info);
 654   content::BrowserThread::PostTask(content::BrowserThread::UI,
 655                                    FROM_HERE,
 656                                    task_closure);
 657 }
 658
 659 void MTPDeviceDelegateImplLinux::PendingRequestDone() {
 660   DCHECK(task_in_progress_);
 661   task_in_progress_ = false;
 662   ProcessNextPendingRequest();
 663 }
 664
 665 void MTPDeviceDelegateImplLinux::ProcessNextPendingRequest() {
 666   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 667   DCHECK(!task_in_progress_);
 668   if (pending_tasks_.empty())
 669     return;
 670
 671   PendingTaskInfo task_info = pending_tasks_.front();
 672   pending_tasks_.pop_front();
 673   RunTask(task_info);
 674 }
 675
 676 void MTPDeviceDelegateImplLinux::OnInitCompleted(bool succeeded) {
 677   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 678   init_state_ = succeeded ? INITIALIZED : UNINITIALIZED;
 679   PendingRequestDone();
 680 }
 681
 682 void MTPDeviceDelegateImplLinux::OnDidGetFileInfo(
 683     const GetFileInfoSuccessCallback& success_callback,
 684     const base::File::Info& file_info) {
 685   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 686   success_callback.Run(file_info);
 687   PendingRequestDone();
 688 }
 689
 690 void MTPDeviceDelegateImplLinux::OnDidGetFileInfoToReadDirectory(
 691     uint32 dir_id,
 692     const ReadDirectorySuccessCallback& success_callback,
 693     const ErrorCallback& error_callback,
 694     const base::File::Info& file_info) {
 695   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 696   DCHECK(task_in_progress_);
 697   if (!file_info.is_directory) {
 698     return HandleDeviceFileError(error_callback,
 699                                  dir_id,
 700                                  base::File::FILE_ERROR_NOT_A_DIRECTORY);
 701   }
 702
 703   base::Closure task_closure =
 704       base::Bind(&ReadDirectoryOnUIThread,
 705                  storage_name_,
 706                  dir_id,
 707                  base::Bind(&MTPDeviceDelegateImplLinux::OnDidReadDirectory,
 708                             weak_ptr_factory_.GetWeakPtr(),
 709                             dir_id,
 710                             success_callback),
 711                  base::Bind(&MTPDeviceDelegateImplLinux::HandleDeviceFileError,
 712                             weak_ptr_factory_.GetWeakPtr(),
 713                             error_callback,
 714                             dir_id));
 715   content::BrowserThread::PostTask(content::BrowserThread::UI,
 716                                    FROM_HERE,
 717                                    task_closure);
 718 }
 719
 720 void MTPDeviceDelegateImplLinux::OnDidGetFileInfoToCreateSnapshotFile(
 721     scoped_ptr<SnapshotRequestInfo> snapshot_request_info,
 722     const base::File::Info& file_info) {
 723   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 724   DCHECK(!current_snapshot_request_info_.get());
 725   DCHECK(snapshot_request_info.get());
 726   DCHECK(task_in_progress_);
 727   base::File::Error error = base::File::FILE_OK;
 728   if (file_info.is_directory)
 729     error = base::File::FILE_ERROR_NOT_A_FILE;
 730   else if (file_info.size < 0 || file_info.size > kuint32max)
 731     error = base::File::FILE_ERROR_FAILED;
 732
 733   if (error != base::File::FILE_OK)
 734     return HandleDeviceFileError(snapshot_request_info->error_callback,
 735                                  snapshot_request_info->file_id,
 736                                  error);
 737
 738   base::File::Info snapshot_file_info(file_info);
 739   // Modify the last modified time to null. This prevents the time stamp
 740   // verfication in LocalFileStreamReader.
 741   snapshot_file_info.last_modified = base::Time();
 742
 743   current_snapshot_request_info_.reset(snapshot_request_info.release());
 744   if (file_info.size == 0) {
 745     // Empty snapshot file.
 746     return OnDidWriteDataIntoSnapshotFile(
 747         snapshot_file_info, current_snapshot_request_info_->snapshot_file_path);
 748   }
 749   WriteDataIntoSnapshotFile(snapshot_file_info);
 750 }
 751
 752 void MTPDeviceDelegateImplLinux::OnDidReadDirectory(
 753     uint32 dir_id,
 754     const ReadDirectorySuccessCallback& success_callback,
 755     const storage::AsyncFileUtil::EntryList& file_list,
 756     bool has_more) {
 757   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 758
 759   FileIdToMTPFileNodeMap::iterator it = file_id_to_node_map_.find(dir_id);
 760   DCHECK(it != file_id_to_node_map_.end());
 761   MTPFileNode* dir_node = it->second;
 762
 763   // Traverse the MTPFileNode tree to reconstuct the full path for |dir_id|.
 764   std::deque<std::string> dir_path_parts;
 765   MTPFileNode* parent_node = dir_node;
 766   while (parent_node->parent()) {
 767     dir_path_parts.push_front(parent_node->file_name());
 768     parent_node = parent_node->parent();
 769   }
 770   base::FilePath dir_path = device_path_;
 771   for (size_t i = 0; i < dir_path_parts.size(); ++i)
 772     dir_path = dir_path.Append(dir_path_parts[i]);
 773
 774   storage::AsyncFileUtil::EntryList normalized_file_list;
 775   for (size_t i = 0; i < file_list.size(); ++i) {
 776     normalized_file_list.push_back(file_list[i]);
 777     storage::DirectoryEntry& entry = normalized_file_list.back();
 778
 779     // |entry.name| has the file id encoded in it. Decode here.
 780     size_t separator_idx = entry.name.find_last_of(',');
 781     DCHECK_NE(std::string::npos, separator_idx);
 782     std::string file_id_str = entry.name.substr(separator_idx);
 783     file_id_str = file_id_str.substr(1);  // Get rid of the comma.
 784     uint32 file_id = 0;
 785     bool ret = base::StringToUint(file_id_str, &file_id);
 786     DCHECK(ret);
 787     entry.name = entry.name.substr(0, separator_idx);
 788
 789     // Refresh the in memory tree.
 790     dir_node->EnsureChildExists(entry.name, file_id);
 791     child_nodes_seen_.insert(entry.name);
 792
 793     // Add to |file_info_cache_|.
 794     file_info_cache_[dir_path.Append(entry.name)] = entry;
 795   }
 796
 797   success_callback.Run(normalized_file_list, has_more);
 798   if (has_more)
 799     return;  // Wait to be called again.
 800
 801   // Last call, finish book keeping and continue with the next request.
 802   dir_node->ClearNonexistentChildren(child_nodes_seen_);
 803   child_nodes_seen_.clear();
 804   file_info_cache_.clear();
 805
 806   PendingRequestDone();
 807 }
 808
 809 void MTPDeviceDelegateImplLinux::OnDidWriteDataIntoSnapshotFile(
 810     const base::File::Info& file_info,
 811     const base::FilePath& snapshot_file_path) {
 812   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 813   DCHECK(current_snapshot_request_info_.get());
 814   current_snapshot_request_info_->success_callback.Run(
 815       file_info, snapshot_file_path);
 816   current_snapshot_request_info_.reset();
 817   PendingRequestDone();
 818 }
 819
 820 void MTPDeviceDelegateImplLinux::OnWriteDataIntoSnapshotFileError(
 821     base::File::Error error) {
 822   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 823   DCHECK(current_snapshot_request_info_.get());
 824   current_snapshot_request_info_->error_callback.Run(error);
 825   current_snapshot_request_info_.reset();
 826   PendingRequestDone();
 827 }
 828
 829 void MTPDeviceDelegateImplLinux::OnDidReadBytes(
 830     const ReadBytesSuccessCallback& success_callback,
 831     const base::File::Info& file_info, int bytes_read) {
 832   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 833   success_callback.Run(file_info, bytes_read);
 834   PendingRequestDone();
 835 }
 836
 837 void MTPDeviceDelegateImplLinux::OnDidFillFileCache(
 838     const base::FilePath& path,
 839     const storage::AsyncFileUtil::EntryList& /* file_list */,
 840     bool has_more) {
 841   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 842   DCHECK(path.IsParent(pending_tasks_.front().path));
 843   if (has_more)
 844     return;  // Wait until all entries have been read.
 845   pending_tasks_.front().cached_path = path;
 846 }
 847
 848 void MTPDeviceDelegateImplLinux::OnFillFileCacheFailed(
 849     base::File::Error /* error */) {
 850   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 851   // When filling the cache fails for the task at the front of the queue, clear
 852   // the path of the task so it will not try to do any more caching. Instead,
 853   // the task will just run and fail the CachedPathToId() lookup.
 854   pending_tasks_.front().path.clear();
 855 }
 856
 857 void MTPDeviceDelegateImplLinux::HandleDeviceFileError(
 858     const ErrorCallback& error_callback,
 859     uint32 file_id,
 860     base::File::Error error) {
 861   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 862
 863   FileIdToMTPFileNodeMap::iterator it = file_id_to_node_map_.find(file_id);
 864   if (it != file_id_to_node_map_.end()) {
 865     MTPFileNode* parent = it->second->parent();
 866     if (parent) {
 867       bool ret = parent->DeleteChild(file_id);
 868       DCHECK(ret);
 869     }
 870   }
 871   error_callback.Run(error);
 872   PendingRequestDone();
 873 }
 874
 875 base::FilePath MTPDeviceDelegateImplLinux::NextUncachedPathComponent(
 876     const base::FilePath& path,
 877     const base::FilePath& cached_path) const {
 878   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 879   DCHECK(cached_path.empty() || cached_path.IsParent(path));
 880
 881   base::FilePath uncached_path;
 882   std::string device_relpath = GetDeviceRelativePath(device_path_, path);
 883   if (!device_relpath.empty() && device_relpath != kRootPath) {
 884     uncached_path = device_path_;
 885     std::vector<std::string> device_relpath_components;
 886     base::SplitString(device_relpath, '/', &device_relpath_components);
 887     DCHECK(!device_relpath_components.empty());
 888     bool all_components_cached = true;
 889     const MTPFileNode* current_node = root_node_.get();
 890     for (size_t i = 0; i < device_relpath_components.size(); ++i) {
 891       current_node = current_node->GetChild(device_relpath_components[i]);
 892       if (!current_node) {
 893         // With a cache miss, check if it is a genuine failure. If so, pretend
 894         // the entire |path| is cached, so there is no further attempt to do
 895         // more caching. The actual operation will then fail.
 896         all_components_cached =
 897             !cached_path.empty() && (uncached_path == cached_path);
 898         break;
 899       }
 900       uncached_path = uncached_path.Append(device_relpath_components[i]);
 901     }
 902     if (all_components_cached)
 903       uncached_path.clear();
 904   }
 905   return uncached_path;
 906 }
 907
 908 void MTPDeviceDelegateImplLinux::FillFileCache(
 909     const base::FilePath& uncached_path) {
 910   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 911   DCHECK(task_in_progress_);
 912
 913   ReadDirectorySuccessCallback success_callback =
 914       base::Bind(&MTPDeviceDelegateImplLinux::OnDidFillFileCache,
 915                  weak_ptr_factory_.GetWeakPtr(),
 916                  uncached_path);
 917   ErrorCallback error_callback =
 918       base::Bind(&MTPDeviceDelegateImplLinux::OnFillFileCacheFailed,
 919                  weak_ptr_factory_.GetWeakPtr());
 920   ReadDirectoryInternal(uncached_path, success_callback, error_callback);
 921 }
 922
 923
 924 bool MTPDeviceDelegateImplLinux::CachedPathToId(const base::FilePath& path,
 925                                                 uint32* id) const {
 926   DCHECK(id);
 927
 928   std::string device_relpath = GetDeviceRelativePath(device_path_, path);
 929   if (device_relpath.empty())
 930     return false;
 931   std::vector<std::string> device_relpath_components;
 932   if (device_relpath != kRootPath)
 933     base::SplitString(device_relpath, '/', &device_relpath_components);
 934   const MTPFileNode* current_node = root_node_.get();
 935   for (size_t i = 0; i < device_relpath_components.size(); ++i) {
 936     current_node = current_node->GetChild(device_relpath_components[i]);
 937     if (!current_node)
 938       return false;
 939   }
 940   *id = current_node->file_id();
 941   return true;
 942 }
 943
 944 void CreateMTPDeviceAsyncDelegate(
 945     const std::string& device_location,
 946     const CreateMTPDeviceAsyncDelegateCallback& callback) {
 947   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 948   callback.Run(new MTPDeviceDelegateImplLinux(device_location));
 949 }