atom/browser/browser.cc

   1 // Copyright (c) 2013 GitHub, Inc.
   2 // Use of this source code is governed by the MIT license that can be
   3 // found in the LICENSE file.
   4
   5 #include "atom/browser/browser.h"
   6
   7 #include <string>
   8 #include <app.h>
   9
  10 #include "atom/browser/atom_browser_main_parts.h"
  11 #include "atom/browser/browser_observer.h"
  12 #include "atom/browser/native_window.h"
  13 #include "atom/browser/window_list.h"
  14 #include "base/files/file_util.h"
  15 #include "base/path_service.h"
  16 #include "base/run_loop.h"
  17 #include "base/threading/thread_task_runner_handle.h"
  18 #include "brightray/browser/brightray_paths.h"
  19 #include "tizen/common/command_line.h"
  20 namespace atom {
  21
  22 Browser::Browser()
  23     : is_quiting_(false),
  24       is_exiting_(false),
  25       is_ready_(false),
  26       is_shutdown_(false),
  27       launched_(false),
  28       locale_manager_(new common::LocaleManager()) {
  29   WindowList::AddObserver(this);
  30 }
  31
  32 Browser::~Browser() {
  33   WindowList::RemoveObserver(this);
  34 }
  35
  36 // static
  37 Browser* Browser::Get() {
  38   return AtomBrowserMainParts::Get()->browser();
  39 }
  40
  41 void Browser::Quit() {
  42   if (is_quiting_)
  43     return;
  44
  45   is_quiting_ = HandleBeforeQuit();
  46   if (!is_quiting_)
  47     return;
  48
  49   if (atom::WindowList::IsEmpty())
  50     NotifyAndShutdown();
  51   else
  52     atom::WindowList::CloseAllWindows();
  53 }
  54
  55 void Browser::Exit(mate::Arguments* args) {
  56   int code = 0;
  57   args->GetNext(&code);
  58
  59   if (!AtomBrowserMainParts::Get()->SetExitCode(code)) {
  60     // Message loop is not ready, quit directly.
  61     exit(code);
  62   } else {
  63     // Prepare to quit when all windows have been closed.
  64     is_quiting_ = true;
  65
  66     // Remember this caller so that we don't emit unrelated events.
  67     is_exiting_ = true;
  68
  69     // Must destroy windows before quitting, otherwise bad things can happen.
  70     if (atom::WindowList::IsEmpty()) {
  71       Shutdown();
  72     } else {
  73       // Unlike Quit(), we do not ask to close window, but destroy the window
  74       // without asking.
  75       atom::WindowList::DestroyAllWindows();
  76     }
  77   }
  78 }
  79
  80 void Browser::Shutdown() {
  81   if (is_shutdown_)
  82     return;
  83
  84   is_shutdown_ = true;
  85   is_quiting_ = true;
  86
  87   for (BrowserObserver& observer : observers_)
  88     observer.OnQuit();
  89
  90   if (base::ThreadTaskRunnerHandle::IsSet()) {
  91     base::ThreadTaskRunnerHandle::Get()->PostTask(
  92         FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
  93     ui_app_exit();
  94   } else {
  95     // There is no message loop available so we are in early stage.
  96     exit(0);
  97   }
  98 }
  99
 100 std::string Browser::GetVersion() const {
 101   if (version_override_.empty()) {
 102     std::string version = GetExecutableFileVersion();
 103     if (!version.empty())
 104       return version;
 105   }
 106
 107   return version_override_;
 108 }
 109
 110 void Browser::SetVersion(const std::string& version) {
 111   version_override_ = version;
 112 }
 113
 114 std::string Browser::GetName() const {
 115   if (name_override_.empty()) {
 116     std::string name = GetExecutableFileProductName();
 117     if (!name.empty())
 118       return name;
 119   }
 120
 121   return name_override_;
 122 }
 123
 124 void Browser::SetName(const std::string& name) {
 125   name_override_ = name;
 126 }
 127
 128 int Browser::GetBadgeCount() {
 129   return badge_count_;
 130 }
 131
 132 bool Browser::OpenFile(const std::string& file_path) {
 133   bool prevent_default = false;
 134   for (BrowserObserver& observer : observers_)
 135     observer.OnOpenFile(&prevent_default, file_path);
 136
 137   return prevent_default;
 138 }
 139
 140 void Browser::OpenURL(const std::string& url) {
 141   for (BrowserObserver& observer : observers_)
 142     observer.OnOpenURL(url);
 143 }
 144
 145 void Browser::Activate(bool has_visible_windows) {
 146   for (BrowserObserver& observer : observers_)
 147     observer.OnActivate(has_visible_windows);
 148 }
 149
 150 void Browser::WillFinishLaunching() {
 151   for (BrowserObserver& observer : observers_)
 152     observer.OnWillFinishLaunching();
 153 }
 154
 155 void Browser::DidFinishLaunching(const base::DictionaryValue& launch_info) {
 156   // Make sure the userData directory is created.
 157   base::FilePath user_data;
 158   if (PathService::Get(brightray::DIR_USER_DATA, &user_data))
 159     base::CreateDirectoryAndGetError(user_data, nullptr);
 160
 161   is_ready_ = true;
 162   for (BrowserObserver& observer : observers_)
 163     observer.OnFinishLaunching(launch_info);
 164 }
 165
 166 void Browser::OnAccessibilitySupportChanged() {
 167   for (BrowserObserver& observer : observers_)
 168     observer.OnAccessibilitySupportChanged();
 169 }
 170
 171 void Browser::RequestLogin(
 172     LoginHandler* login_handler,
 173     std::unique_ptr<base::DictionaryValue> request_details) {
 174   for (BrowserObserver& observer : observers_)
 175     observer.OnLogin(login_handler, *(request_details.get()));
 176 }
 177
 178 void Browser::NotifyAndShutdown() {
 179   if (is_shutdown_)
 180     return;
 181
 182   bool prevent_default = false;
 183   for (BrowserObserver& observer : observers_)
 184     observer.OnWillQuit(&prevent_default);
 185
 186   if (prevent_default) {
 187     is_quiting_ = false;
 188     return;
 189   }
 190
 191   Shutdown();
 192 }
 193
 194 bool Browser::HandleBeforeQuit() {
 195   bool prevent_default = false;
 196   for (BrowserObserver& observer : observers_)
 197     observer.OnBeforeQuit(&prevent_default);
 198
 199   return !prevent_default;
 200 }
 201
 202 void Browser::OnWindowCloseCancelled(NativeWindow* window) {
 203   if (is_quiting_)
 204     // Once a beforeunload handler has prevented the closing, we think the quit
 205     // is cancelled too.
 206     is_quiting_ = false;
 207 }
 208
 209 void Browser::OnWindowAllClosed() {
 210   if (is_exiting_) {
 211     Shutdown();
 212   } else if (is_quiting_) {
 213     NotifyAndShutdown();
 214   } else {
 215     for (BrowserObserver& observer : observers_)
 216       observer.OnWindowAllClosed();
 217   }
 218 }
 219
 220 void Browser::Hide() {
 221   for (BrowserObserver& observer : observers_)
 222     observer.OnSuspend();
 223 }
 224
 225 void Browser::Show() {
 226   for (BrowserObserver& observer : observers_)
 227     observer.OnResume();
 228 }
 229
 230 void Browser::Initialize() {
 231   common::CommandLine* runtime_cmd = common::CommandLine::ForCurrentProcess();
 232   std::string appid = runtime_cmd->GetAppIdFromCommandLine("/usr/bin/electron");
 233    //TODO: update the appid from binary name to electron
 234   if (appid != "electron") {
 235     auto appdata_manager = common::ApplicationDataManager::GetInstance();
 236     common::ApplicationData* appdata = appdata_manager->GetApplicationData(appid);
 237
 238     resource_manager_.reset(
 239         new common::ResourceManager(appdata, locale_manager_.get()));
 240   }
 241 }
 242
 243 void Browser::AppControl(std::unique_ptr<common::AppControl> appcontrol) {
 244   std::unique_ptr<common::ResourceManager::Resource> res =
 245       resource_manager_->GetStartResource(appcontrol.get());
 246   bool do_reset = res->should_reset();
 247 //To do: Implementation of reset case according to parsed config file parameter.
 248 }
 249
 250 void Browser::Launch(std::unique_ptr<common::AppControl> appcontrol) {
 251   launched_ = true;
 252 //To do:Implementation of relaunching of app
 253 }
 254
 255 }  // namespace atom