Add a new field "source" in launchData of chrome.app.runtime.onLaunched() to trace launch source.

apps/launcher.cc

 // Copyright 2013 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 "apps/launcher.h"
 
 #include <set>
 #include <utility>
 
 #include "base/command_line.h"
@@ skipping 64 matching lines @@
     return !file_path->empty();
   }
 
   if (!current_directory.IsAbsolute())
     return false;
 
   *file_path = current_directory.Append(*file_path);
   return true;
 }
 
-// Helper method to launch the platform app |extension| with no data. This
-// should be called in the fallback case, where it has been impossible to
-// load or obtain file launch data.
-void LaunchPlatformAppWithNoData(Profile* profile, const Extension* extension) {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  AppRuntimeEventRouter::DispatchOnLaunchedEvent(profile, extension);
-}
-
 // Class to handle launching of platform apps to open specific paths.
 // An instance of this class is created for each launch. The lifetime of these
 // instances is managed by reference counted pointers. As long as an instance
 // has outstanding tasks on a message queue it will be retained; once all
 // outstanding tasks are completed it will be deleted.
 class PlatformAppPathLauncher
     : public base::RefCountedThreadSafe<PlatformAppPathLauncher> {
  public:
   PlatformAppPathLauncher(Profile* profile,
                           const Extension* extension,
                           const std::vector<base::FilePath>& file_paths)
       : profile_(profile),
         extension_(extension),
         file_paths_(file_paths),
         collector_(profile) {}
 
   PlatformAppPathLauncher(Profile* profile,
                           const Extension* extension,
                           const base::FilePath& file_path)
       : profile_(profile), extension_(extension), collector_(profile) {
     if (!file_path.empty())
       file_paths_.push_back(file_path);
   }
 
   void Launch() {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     if (file_paths_.empty()) {
-      LaunchPlatformAppWithNoData(profile_, extension_);
+      LaunchWithNoLaunchData();
       return;
     }
 
     for (size_t i = 0; i < file_paths_.size(); ++i) {
       DCHECK(file_paths_[i].IsAbsolute());
     }
 
     if (HasFileSystemWritePermission(extension_)) {
       PrepareFilesForWritableApp(
           file_paths_,
@@ skipping 52 matching lines @@
         file_paths_,
         base::Bind(&PlatformAppPathLauncher::OnMimeTypesCollected, this));
   }
 
   void OnFilesInvalid(const base::FilePath& /* error_path */) {
     LaunchWithNoLaunchData();
   }
 
   void LaunchWithNoLaunchData() {
     // This method is required as an entry point on the UI thread.
-    LaunchPlatformAppWithNoData(profile_, extension_);
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
+    AppRuntimeEventRouter::DispatchOnLaunchedEvent(
+        profile_, extension_, extensions::SOURCE_UNKNOWN);

[benwells, 2014/10/28 21:22:47]

Why is this unknown? I think we should plumb through the reason for the launch
to this point.

[cylee1, 2014/10/29 16:39:59]

This function is called only for the failure case of file handler now. I had a
hard time deciding whether if I should pass SOURCE_FILE_HANDLER here because it
actually passes no data in failure case.
Besides I remember a browser test somewhere asserts an empty object is passed in
the case. Should I make it SOURCE_FILE_HANDLER and change the test case?

[cylee1, 2014/10/29 17:23:49]

Changed to SOURCE_FILE_HANDLER anyway since it's only called by triggered by
file handler.

   }
 
   void OnMimeTypesCollected(scoped_ptr<std::vector<std::string> > mime_types) {
     DCHECK(file_paths_.size() == mime_types->size());
 
     // If fetching a mime type failed, then use a fallback one.
     for (size_t i = 0; i < mime_types->size(); ++i) {
       const std::string mime_type =
           !(*mime_types)[i].empty() ? (*mime_types)[i] : kFallbackMimeType;
       mime_types_.push_back(mime_type);
@@ skipping 99 matching lines @@
   extensions::app_file_handler_util::MimeTypeCollector collector_;
 
   DISALLOW_COPY_AND_ASSIGN(PlatformAppPathLauncher);
 };
 
 }  // namespace
 
 void LaunchPlatformAppWithCommandLine(Profile* profile,
                                       const Extension* extension,
                                       const CommandLine& command_line,
-                                      const base::FilePath& current_directory) {
+                                      const base::FilePath& current_directory,
+                                      extensions::AppLaunchSource source) {
   // An app with "kiosk_only" should not be installed and launched
   // outside of ChromeOS kiosk mode in the first place. This is a defensive
   // check in case this scenario does occur.
   if (extensions::KioskModeInfo::IsKioskOnly(extension)) {
     bool in_kiosk_mode = false;
 #if defined(OS_CHROMEOS)
     user_manager::UserManager* user_manager = user_manager::UserManager::Get();
     in_kiosk_mode = user_manager && user_manager->IsLoggedInAsKioskApp();
 #endif
     if (!in_kiosk_mode) {
@@ skipping 10 matching lines @@
 #else
   base::CommandLine::StringType about_blank_url(url::kAboutBlankURL);
 #endif
   CommandLine::StringVector args = command_line.GetArgs();
   // Browser tests will add about:blank to the command line. This should
   // never be interpreted as a file to open, as doing so with an app that
   // has write access will result in a file 'about' being created, which
   // causes problems on the bots.
   if (args.empty() || (command_line.HasSwitch(switches::kTestType) &&
                        args[0] == about_blank_url)) {
-    LaunchPlatformAppWithNoData(profile, extension);
+    AppRuntimeEventRouter::DispatchOnLaunchedEvent(profile, extension, source);
     return;
   }
 
   base::FilePath file_path(command_line.GetArgs()[0]);
   scoped_refptr<PlatformAppPathLauncher> launcher =
       new PlatformAppPathLauncher(profile, extension, file_path);
   launcher->LaunchWithRelativePath(current_directory);
 }
 
 void LaunchPlatformAppWithPath(Profile* profile,
                                const Extension* extension,
                                const base::FilePath& file_path) {
   scoped_refptr<PlatformAppPathLauncher> launcher =
       new PlatformAppPathLauncher(profile, extension, file_path);
   launcher->Launch();
 }
 
-void LaunchPlatformApp(Profile* profile, const Extension* extension) {
+void LaunchPlatformApp(Profile* profile,
+                       const Extension* extension,
+                       extensions::AppLaunchSource source) {
   LaunchPlatformAppWithCommandLine(profile,
                                    extension,
                                    CommandLine(CommandLine::NO_PROGRAM),
-                                   base::FilePath());
+                                   base::FilePath(),
+                                   source);
 }
 
 void LaunchPlatformAppWithFileHandler(
     Profile* profile,
     const Extension* extension,
     const std::string& handler_id,
     const std::vector<base::FilePath>& file_paths) {
   scoped_refptr<PlatformAppPathLauncher> launcher =
       new PlatformAppPathLauncher(profile, extension, file_paths);
   launcher->LaunchWithHandler(handler_id);
 }
 
 void RestartPlatformApp(Profile* profile, const Extension* extension) {
   EventRouter* event_router = EventRouter::Get(profile);
   bool listening_to_restart = event_router->
       ExtensionHasEventListener(extension->id(),
                                 app_runtime::OnRestarted::kEventName);
 
   if (listening_to_restart) {
     AppRuntimeEventRouter::DispatchOnRestartedEvent(profile, extension);
     return;
   }
-

[benwells, 2014/10/28 21:22:47]

Nit: keep the empty line here.

[cylee1, 2014/10/29 16:39:59]

Done.

   extensions::ExtensionPrefs* extension_prefs =
       extensions::ExtensionPrefs::Get(profile);
   bool had_windows = extension_prefs->IsActive(extension->id());
   extension_prefs->SetIsActive(extension->id(), false);
   bool listening_to_launch = event_router->
       ExtensionHasEventListener(extension->id(),
                                 app_runtime::OnLaunched::kEventName);
 
-  if (listening_to_launch && had_windows)
-    LaunchPlatformAppWithNoData(profile, extension);
+  if (listening_to_launch && had_windows) {
+    AppRuntimeEventRouter::DispatchOnLaunchedEvent(
+        profile, extension, extensions::SOURCE_RESTART);
+  }
 }
 
 void LaunchPlatformAppWithUrl(Profile* profile,
                               const Extension* extension,
                               const std::string& handler_id,
                               const GURL& url,
                               const GURL& referrer_url) {
   AppRuntimeEventRouter::DispatchOnLaunchedEventWithUrl(
       profile, extension, handler_id, url, referrer_url);
 }
 
 }  // namespace apps