Do not pop up Files app, when the recovery tool is running.

chrome/browser/chromeos/extensions/file_manager/event_router.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/extensions/file_manager/event_router.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/prefs/pref_change_registrar.h"
@@ skipping 20 matching lines @@
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/pref_names.h"
 #include "chromeos/login/login_state.h"
 #include "chromeos/network/network_handler.h"
 #include "chromeos/network/network_state_handler.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/render_process_host.h"
 #include "extensions/browser/event_router.h"
+#include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_system.h"
 #include "webkit/common/fileapi/file_system_types.h"
 #include "webkit/common/fileapi/file_system_util.h"
 
 using chromeos::disks::DiskMountManager;
 using chromeos::NetworkHandler;
 using content::BrowserThread;
 using drive::DriveIntegrationService;
 using drive::DriveIntegrationServiceFactory;
 
@@ skipping 62 matching lines @@
   // JavaScript does not have 64-bit integers. Instead we use double, which
   // is in IEEE 754 formant and accurate up to 52-bits in JS, and in practice
   // in C++. Larger values are rounded.
   status->processed.reset(
       new double(static_cast<double>(job_info.num_completed_bytes)));
   status->total.reset(
       new double(static_cast<double>(job_info.num_total_bytes)));
 }
 
 // Checks for availability of the Google+ Photos app.
+// TODO(mtomasz): Replace with crbug.com/341902 solution.
 bool IsGooglePhotosInstalled(Profile *profile) {
   ExtensionService* service =
       extensions::ExtensionSystem::Get(profile)->extension_service();
   if (!service)
     return false;
 
   // Google+ Photos uses several ids for different channels. Therefore, all of
   // them should be checked.
   const std::string kGooglePlusPhotosIds[] = {
-    "ebpbnabdhheoknfklmpddcdijjkmklkp",  // G+ Photos staging
-    "efjnaogkjbogokcnohkmnjdojkikgobo",  // G+ Photos prod
-    "ejegoaikibpmikoejfephaneibodccma"   // G+ Photos dev
+      "ebpbnabdhheoknfklmpddcdijjkmklkp",  // G+ Photos staging
+      "efjnaogkjbogokcnohkmnjdojkikgobo",  // G+ Photos prod
+      "ejegoaikibpmikoejfephaneibodccma"   // G+ Photos dev
   };
 
   for (size_t i = 0; i < arraysize(kGooglePlusPhotosIds); ++i) {
     if (service->GetExtensionById(kGooglePlusPhotosIds[i],
                                   false /* include_disable */) != NULL)
       return true;
   }
 
   return false;
 }
 
+// Checks if the Recovery Tool is running. This is a temporary solution.
+// TODO(mtomasz): Replace with crbug.com/341902 solution.
+bool IsRecoveryToolRunning(Profile* profile) {
+  ExtensionService* service =
+      extensions::ExtensionSystem::Get(profile)->extension_service();
+  if (!service)
+    return false;
+  extensions::ExtensionPrefs* extension_prefs = service->extension_prefs();
+  if (!extension_prefs)
+    return false;
+
+  const std::string kRecoveryToolIds[] = {
+      "kkebgepbbgbcmghedmmdfcbdcodlkngh",  // Recovert tool staging
+      "jndclpdbaamdhonoechobihbbiimdgai"   // Recovery tool prod
+  };
+
+  for (size_t i = 0; i < arraysize(kRecoveryToolIds); ++i) {
+    const std::string extension_id = kRecoveryToolIds[i];
+    if (service->GetExtensionById(extension_id, false /* include_disable */) !=
+        NULL) {
+      if (extension_prefs->IsExtensionRunning(extension_id))
+        return true;
+    }
+  }
+
+  return false;
+}
+
 // Sends an event named |event_name| with arguments |event_args| to extensions.
 void BroadcastEvent(Profile* profile,
                     const std::string& event_name,
                     scoped_ptr<base::ListValue> event_args) {
   extensions::ExtensionSystem::Get(profile)->event_router()->
       BroadcastEvent(make_scoped_ptr(
           new extensions::Event(event_name, event_args.Pass())));
 }
 
 file_browser_private::MountCompletedStatus
@@ skipping 527 matching lines @@
     const base::FilePath& mount_path) {
   // Do not attempt to open File Manager while the login is in progress or
   // the screen is locked or running in kiosk app mode and make sure the file
   // manager is opened only for the active user.
   if (chromeos::LoginDisplayHostImpl::default_host() ||
       chromeos::ScreenLocker::default_screen_locker() ||
       chrome::IsRunningInForcedAppMode() ||
       profile_ != ProfileManager::GetActiveUserProfile())
     return;
 
+  // Do not pop-up the File Manager, if the recovery tool is running.
+  if (IsRecoveryToolRunning(profile_))
+    return;
+
   // According to DCF (Design rule of Camera File system) by JEITA / CP-3461
   // cameras should have pictures located in the DCIM root directory.
   const base::FilePath dcim_path = mount_path.Append(
       FILE_PATH_LITERAL("DCIM"));
 
-  // If there is no DCIM folder or an external photo importer is not available,
-  // then launch Files.app.
+  // If there is a DCIM folder and Google+ Photos is installed, then do not
+  // launch Files.app. Also, do not show Files app, if the recovery tool is
+  // running.

[kinaba, 2014/02/19 09:10:20]

The comment "Also, do not show Files app, if the recovery tool is running." is
already written few lines above.

[mtomasz, 2014/02/19 09:37:48]

Done.

   DirectoryExistsOnUIThread(
       dcim_path,
-      IsGooglePhotosInstalled(profile_) ?
-      base::Bind(&base::DoNothing) :
-      base::Bind(&util::OpenRemovableDrive, profile_, mount_path),
+      IsGooglePhotosInstalled(profile_)
+          ? base::Bind(&base::DoNothing)
+          : base::Bind(&util::OpenRemovableDrive, profile_, mount_path),
       base::Bind(&util::OpenRemovableDrive, profile_, mount_path));
 }
 
 void EventRouter::DispatchDeviceEvent(
     file_browser_private::DeviceEventType type,
     const std::string& device_path) {
   file_browser_private::DeviceEvent event;
   event.type = type;
   event.device_path = device_path;
   BroadcastEvent(profile_,
@@ skipping 129 matching lines @@
   }
 }
 
 void EventRouter::OnOwnerEntryChanged(aura::Window* window) {
   BroadcastEvent(profile_,
                  file_browser_private::OnDesktopChanged::kEventName,
                  file_browser_private::OnDesktopChanged::Create());
 }
 
 }  // namespace file_manager