NOT FOR REVIEW: Aura on Android

chrome/browser/media_galleries/fileapi/mtp_device_map_service.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/media_galleries/fileapi/mtp_device_map_service.h"
 
 #include <string>
 #include <utility>
 
 #include "base/stl_util.h"
@@ skipping 10 matching lines @@
 
 // static
 MTPDeviceMapService* MTPDeviceMapService::GetInstance() {
   return g_mtp_device_map_service.Pointer();
 }
 
 void MTPDeviceMapService::RegisterMTPFileSystem(
     const base::FilePath::StringType& device_location,
     const std::string& filesystem_id,
     const bool read_only) {
+#if defined(OS_ANDROID)
+  // No CreateMTPDeviceAsyncDelegate implementation
+  NOTIMPLEMENTED();
+#else
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   DCHECK(!device_location.empty());
   DCHECK(!filesystem_id.empty());
 
   const AsyncDelegateKey key = GetAsyncDelegateKey(device_location, read_only);
   if (!ContainsKey(mtp_device_usage_map_, key)) {
     // Note that this initializes the delegate asynchronously, but since
     // the delegate will only be used from the IO thread, it is guaranteed
     // to be created before use of it expects it to be there.
     CreateMTPDeviceAsyncDelegate(
         device_location, read_only,
         base::Bind(&MTPDeviceMapService::AddAsyncDelegate,
                    base::Unretained(this), device_location, read_only));
     mtp_device_usage_map_[key] = 0;
   }
 
   mtp_device_usage_map_[key]++;
   mtp_device_map_[filesystem_id] = make_pair(device_location, read_only);
+#endif
 }
 
 void MTPDeviceMapService::RevokeMTPFileSystem(
     const std::string& filesystem_id) {
+#if defined(OS_ANDROID)
+  // No RemoveAsyncDelegate implementation
+  NOTIMPLEMENTED();
+#else
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   DCHECK(!filesystem_id.empty());
 
   MTPDeviceFileSystemMap::iterator it = mtp_device_map_.find(filesystem_id);
   if (it != mtp_device_map_.end()) {
     const base::FilePath::StringType device_location = it->second.first;
     const bool read_only = it->second.second;
 
     mtp_device_map_.erase(it);
 
     const AsyncDelegateKey key =
         GetAsyncDelegateKey(device_location, read_only);
     MTPDeviceUsageMap::iterator delegate_it = mtp_device_usage_map_.find(key);
     DCHECK(delegate_it != mtp_device_usage_map_.end());
 
     mtp_device_usage_map_[key]--;
     if (mtp_device_usage_map_[key] == 0) {
       mtp_device_usage_map_.erase(delegate_it);
       RemoveAsyncDelegate(device_location, read_only);
     }
   }
+#endif
 }
 
 void MTPDeviceMapService::AddAsyncDelegate(
     const base::FilePath::StringType& device_location,
     const bool read_only,
     MTPDeviceAsyncDelegate* delegate) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   DCHECK(delegate);
   DCHECK(!device_location.empty());
 
@@ skipping 60 matching lines @@
              ? async_delegate_map_it->second
              : NULL;
 }
 
 MTPDeviceMapService::MTPDeviceMapService() {
 }
 
 MTPDeviceMapService::~MTPDeviceMapService() {
   DCHECK(mtp_device_usage_map_.empty());
 }