[fsp] Unmount file systems when the providing extension gets unloaded.

chrome/browser/chromeos/file_system_provider/service_unittest.cc

 // Copyright 2014 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 <string>
 #include <vector>
 
 #include "base/files/file.h"
+#include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "chrome/browser/chromeos/file_system_provider/observer.h"
 #include "chrome/browser/chromeos/file_system_provider/provided_file_system_info.h"
 #include "chrome/browser/chromeos/file_system_provider/service.h"
 #include "chrome/browser/chromeos/login/fake_user_manager.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/test/test_browser_thread_bundle.h"
+#include "extensions/browser/extension_registry.h"
+#include "extensions/common/extension.h"
+#include "extensions/common/manifest_constants.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/browser/fileapi/external_mount_points.h"
 
 namespace chromeos {
 namespace file_system_provider {
 namespace {
 
 const char kExtensionId[] = "mbflcebpggnecokmikipoihdbecnjfoj";
 const char kFileSystemName[] = "Camera Pictures";
 
@@ skipping 30 matching lines @@
   virtual void OnProvidedFileSystemUnmount(
       const ProvidedFileSystemInfo& file_system_info,
       base::File::Error error) OVERRIDE {
     unmounts.push_back(Event(file_system_info, error));
   }
 
   std::vector<Event> mounts;
   std::vector<Event> unmounts;
 };
 
+// Creates a fake extension with the specified |extension_id|.
+scoped_refptr<extensions::Extension> createFakeExtension(

[hashimoto, 2014/03/27 09:18:49]

Hmm, it's generally better to return raw-pointer than scoped_refptr from factory
functions of ref-counted objects. 
(see
https://groups.google.com/a/chromium.org/d/msg/chromium-dev/CNTCtqGkk0M/YF-Q-...)

But extensions::Extension::Create is already returning scoped_refptr.
So, in this case, returning scoped_refptr seems the safer choice.

[mtomasz, 2014/03/28 06:01:10]

I think in this case, there is no other choice. If we returned a raw pointer, it
would become invalid almost immediately.

+    const std::string& extension_id) {
+  base::DictionaryValue manifest;
+  std::string error;
+  manifest.SetString(extensions::manifest_keys::kVersion, "1.0.0.0");
+  manifest.SetString(extensions::manifest_keys::kName, "unused");
+  return extensions::Extension::Create(base::FilePath(),
+                                       extensions::Manifest::UNPACKED,
+                                       manifest,
+                                       extensions::Extension::NO_FLAGS,
+                                       kExtensionId,
+                                       &error);
+}
+
 }  // namespace
 
 class FileSystemProviderServiceTest : public testing::Test {
  protected:
   FileSystemProviderServiceTest() {}
   virtual ~FileSystemProviderServiceTest() {}
 
   virtual void SetUp() OVERRIDE {
+    profile_.reset(new TestingProfile);
     user_manager_ = new FakeUserManager();
+    user_manager_->AddUser(profile_->GetProfileName());
     user_manager_enabler_.reset(new ScopedUserManagerEnabler(user_manager_));
-    profile_.reset(new TestingProfile);
-    user_manager_->AddUser(profile_->GetProfileName());
-    file_system_provider_service_.reset(new Service(profile_.get()));
+    extension_registry_.reset(new extensions::ExtensionRegistry);
+    file_system_provider_service_.reset(
+        new Service(profile_.get(), extension_registry_.get()));
+    extension_ = createFakeExtension(kExtensionId);
   }
 
   virtual void TearDown() {
     fileapi::ExternalMountPoints::GetSystemInstance()->RevokeAllFileSystems();
   }
 
   content::TestBrowserThreadBundle thread_bundle_;
   scoped_ptr<TestingProfile> profile_;
+  FakeUserManager* user_manager_;
   scoped_ptr<ScopedUserManagerEnabler> user_manager_enabler_;
-  FakeUserManager* user_manager_;
+  scoped_ptr<extensions::ExtensionRegistry> extension_registry_;
   scoped_ptr<Service> file_system_provider_service_;
+  scoped_refptr<extensions::Extension> extension_;
 };
 
 TEST_F(FileSystemProviderServiceTest, MountFileSystem) {
   LoggingObserver observer;
   file_system_provider_service_->AddObserver(&observer);
 
   int file_system_id = file_system_provider_service_->MountFileSystem(
       kExtensionId, kFileSystemName);
 
   EXPECT_LT(0, file_system_id);
@@ skipping 93 matching lines @@
   EXPECT_EQ(kFileSystemName,
             observer.unmounts[0].file_system_info().file_system_name());
 
   std::vector<ProvidedFileSystemInfo> file_system_info_list =
       file_system_provider_service_->GetProvidedFileSystemInfoList();
   ASSERT_EQ(0u, file_system_info_list.size());
 
   file_system_provider_service_->RemoveObserver(&observer);
 }
 
+TEST_F(FileSystemProviderServiceTest, UnmountFileSystem_OnExtensionUnload) {
+  LoggingObserver observer;
+  file_system_provider_service_->AddObserver(&observer);
+
+  int file_system_id = file_system_provider_service_->MountFileSystem(
+      kExtensionId, kFileSystemName);
+  EXPECT_LT(0, file_system_id);
+  ASSERT_EQ(1u, observer.mounts.size());
+
+  // Directly call the observer's method.
+  file_system_provider_service_->OnExtensionUnloaded(extension_.get());
+
+  ASSERT_EQ(1u, observer.unmounts.size());
+  EXPECT_EQ(base::File::FILE_OK, observer.unmounts[0].error());
+
+  EXPECT_EQ(kExtensionId,
+            observer.unmounts[0].file_system_info().extension_id());
+  EXPECT_EQ(1, observer.unmounts[0].file_system_info().file_system_id());
+  EXPECT_EQ(
+      "/provided/mbflcebpggnecokmikipoihdbecnjfoj-1-testing_profile-hash",

[hashimoto, 2014/03/27 09:18:49]

This EXPECT looks fragile for changes in UserManager/Profile implementation.
Could you make this EXPECT more robust? (e.g. instead of writing this cryptic
hash down directly in this test, get the hash from the profile or somewhere
appropriate)

[mtomasz, 2014/03/28 06:01:10]

I was thinking about it, but I was concerned that the test would be less easy to
read, without much advantages. It would be either:

1) EXPECT_EQ(ConstructProvidedMountPath(kExtensionId, 1), ...mount_path());

2) EXPECT_EQ("/provided/mbflcebpggnecokmikipoihdbecnjfoj-1-" +
testing_profile_hash_), ...mount_path()));

These two values: 'testing_profile and 'hash' are hardcoded in testing-only
classes, so I don't think they will change often.

https://code.google.com/p/chromium/codesearch#chromium/src/chrome/test/base/t...

https://code.google.com/p/chromium/codesearch#chromium/src/chrome/browser/chr...

I don't have a strong opinion here though. WDYT?

+      observer.unmounts[0].file_system_info().mount_path().AsUTF8Unsafe());
+  EXPECT_EQ(kFileSystemName,
+            observer.unmounts[0].file_system_info().file_system_name());
+
+  std::vector<ProvidedFileSystemInfo> file_system_info_list =
+      file_system_provider_service_->GetProvidedFileSystemInfoList();
+  ASSERT_EQ(0u, file_system_info_list.size());
+
+  file_system_provider_service_->RemoveObserver(&observer);
+}
+
 TEST_F(FileSystemProviderServiceTest, UnmountFileSystem_WrongExtensionId) {
   LoggingObserver observer;
   file_system_provider_service_->AddObserver(&observer);
 
   const std::string kWrongExtensionId = "helloworldhelloworldhelloworldhe";
 
   int file_system_id = file_system_provider_service_->MountFileSystem(
       kExtensionId, kFileSystemName);
   EXPECT_LT(0, file_system_id);
   ASSERT_EQ(1u, observer.mounts.size());
@@ skipping 12 matching lines @@
 
   std::vector<ProvidedFileSystemInfo> file_system_info_list =
       file_system_provider_service_->GetProvidedFileSystemInfoList();
   ASSERT_EQ(1u, file_system_info_list.size());
 
   file_system_provider_service_->RemoveObserver(&observer);
 }
 
 }  // namespace file_system_provider
 }  // namespace chromeos