Add notification and observer to copy the file between other users.

chrome/browser/chromeos/extensions/file_manager/event_router.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 "chrome/browser/chromeos/extensions/file_manager/event_router.h"
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/prefs/pref_change_registrar.h"
@@ skipping 251 matching lines @@
       return "SecurityError";
     case base::File::FILE_ERROR_NO_SPACE:
       return "QuotaExceededError";
     case base::File::FILE_ERROR_INVALID_URL:
       return "EncodingError";
     default:
       return "InvalidModificationError";
   }
 }
 
+void GrantAccessForAddedProfileToRunningInstance(Profile* added_profile,
+                                                 Profile* running_profile) {
+  extensions::ProcessManager* const process_manager =
+      extensions::ExtensionSystem::Get(running_profile)->process_manager();
+  if (!process_manager)
+    return;
+
+  extensions::ExtensionHost* const extension_host =
+      process_manager->GetBackgroundHostForExtension(kFileManagerAppId);
+  if (!extension_host || !extension_host->render_process_host())
+    return;
+
+  const int id = extension_host->render_process_host()->GetID();
+  file_manager::util::SetupProfileFileAccessPermissions(id, added_profile);
+}
+
 // Checks if we should send a progress event or not according to the
 // |last_time| of sending an event. If |always| is true, the function always
 // returns true. If the function returns true, the function also updates
 // |last_time|.
 bool ShouldSendProgressEvent(bool always, base::Time* last_time) {
   const base::Time now = base::Time::Now();
   const int64 delta = (now - *last_time).InMilliseconds();
   // delta < 0 may rarely happen if system clock is synced and rewinded.
   // To be conservative, we don't skip in that case.
   if (!always && 0 <= delta && delta < kProgressEventFrequencyInMilliseconds) {
@@ skipping 175 matching lines @@
   }
 
   pref_change_registrar_->Init(profile_->GetPrefs());
   base::Closure callback =
       base::Bind(&EventRouter::OnFileManagerPrefsChanged,
                  weak_factory_.GetWeakPtr());
   pref_change_registrar_->Add(prefs::kDisableDriveOverCellular, callback);
   pref_change_registrar_->Add(prefs::kDisableDriveHostedFiles, callback);
   pref_change_registrar_->Add(prefs::kDisableDrive, callback);
   pref_change_registrar_->Add(prefs::kUse24HourClock, callback);
+
+  notification_registrar_.Add(this,
+                              chrome::NOTIFICATION_PROFILE_ADDED,
+                              content::NotificationService::AllSources());
 }
 
 // File watch setup routines.
 void EventRouter::AddFileWatch(const base::FilePath& local_path,
                                const base::FilePath& virtual_path,
                                const std::string& extension_id,
                                const BoolCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
@@ skipping 452 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // Do nothing.
 }
 
 void EventRouter::OnFormatCompleted(const std::string& device_path,
                                     bool success) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // Do nothing.
 }
 
+void EventRouter::Observe(int type,
+                          const content::NotificationSource& source,
+                          const content::NotificationDetails& details) {
+  if (type == chrome::NOTIFICATION_PROFILE_ADDED) {
+    Profile* const added_profile = content::Source<Profile>(source).ptr();
+    if (!added_profile->IsOffTheRecord())
+      GrantAccessForAddedProfileToRunningInstance(added_profile, profile_);
+  }
+}
+
 }  // namespace file_manager