Introduce apps API target in //apps and move app.runtime API into it

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 "apps/apps_client.h"
+#include "apps/browser/api/app_runtime/app_runtime_api.h"
+#include "apps/browser/file_handler_util.h"
+#include "apps/common/api/app_runtime.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
-#include "chrome/browser/extensions/api/app_runtime/app_runtime_api.h"
 #include "chrome/browser/extensions/api/file_handlers/app_file_handler_util.h"
 #include "chrome/browser/extensions/api/file_system/file_system_api.h"
 #include "chrome/browser/profiles/profile.h"
-#include "chrome/common/extensions/api/app_runtime.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_host.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/lazy_background_task_queue.h"
 #include "extensions/browser/process_manager.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_messages.h"
 #include "extensions/common/manifest_handlers/kiosk_mode_info.h"
 #include "net/base/mime_util.h"
 #include "net/base/net_util.h"
 #include "url/gurl.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/drive/file_errors.h"
 #include "chrome/browser/chromeos/drive/file_system_interface.h"
 #include "chrome/browser/chromeos/drive/file_system_util.h"
 #include "chrome/browser/chromeos/login/user_manager.h"
 #endif
 
 #if defined(OS_WIN)
 #include "win8/util/win8_util.h"
 #endif
 
-namespace app_runtime = extensions::api::app_runtime;
+namespace app_runtime = apps::api::app_runtime;
 
+using apps::file_handler_util::GrantedFileEntry;
 using content::BrowserThread;
 using extensions::app_file_handler_util::CheckWritableFiles;
 using extensions::app_file_handler_util::FileHandlerForId;
 using extensions::app_file_handler_util::FileHandlerCanHandleFile;
 using extensions::app_file_handler_util::FirstFileHandlerForFile;
 using extensions::app_file_handler_util::CreateFileEntry;
-using extensions::app_file_handler_util::GrantedFileEntry;
 using extensions::app_file_handler_util::HasFileSystemWritePermission;
 using extensions::EventRouter;
 using extensions::Extension;
 using extensions::ExtensionHost;
 using extensions::ExtensionSystem;
 
 namespace apps {
 
 namespace {
 
@@ skipping 31 matching lines @@
   }
   *path = absolute_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(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  extensions::AppEventRouter::DispatchOnLaunchedEvent(profile, extension);
+  AppEventRouter::DispatchOnLaunchedEvent(profile, extension);
 }
 
 // Class to handle launching of platform apps to open a specific path.
 // 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:
@@ skipping 167 matching lines @@
       LOG(ERROR) << "Could not load app page for " << extension_->id();
       return;
     }
 
     GrantedFileEntry file_entry =
         CreateFileEntry(profile_,
                         extension_,
                         host->render_process_host()->GetID(),
                         file_path_,
                         false);
-    extensions::AppEventRouter::DispatchOnLaunchedEventWithFileEntry(
+    AppEventRouter::DispatchOnLaunchedEventWithFileEntry(
         profile_, extension_, handler_id_, mime_type, file_entry);
   }
 
   // The profile the app should be run in.
   Profile* profile_;
   // The extension providing the app.
   const Extension* extension_;
   // The path to be passed through to the app.
   const base::FilePath file_path_;
   // The ID of the file handler used to launch the app.
@@ skipping 71 matching lines @@
   // In restart we are just making sure launch doesn't slip through.
   if (win8::IsSingleWindowMetroMode())
     return;
 #endif
   EventRouter* event_router = EventRouter::Get(profile);
   bool listening_to_restart = event_router->
       ExtensionHasEventListener(extension->id(),
                                 app_runtime::OnRestarted::kEventName);
 
   if (listening_to_restart) {
-    extensions::AppEventRouter::DispatchOnRestartedEvent(profile, extension);
+    AppEventRouter::DispatchOnRestartedEvent(profile, extension);
     return;
   }
 
   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);
 }
 
 void LaunchPlatformAppWithUrl(Profile* profile,
                               const Extension* extension,
                               const std::string& handler_id,
                               const GURL& url,
                               const GURL& referrer_url) {
-  extensions::AppEventRouter::DispatchOnLaunchedEventWithUrl(
+  AppEventRouter::DispatchOnLaunchedEventWithUrl(
       profile, extension, handler_id, url, referrer_url);
 }
 
 }  // namespace apps