LCOV - app.info - browser/app/nsBrowserApp.cpp

LCOV - code coverage report
| Current view: | directory - browser/app - nsBrowserApp.cpp (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 73 | 17 | 23.3 %
| Date: | 2012-04-07 | Functions: | 6 | 2 | 33.3 %

           1                 : /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
           2                 : /* ***** BEGIN LICENSE BLOCK *****
           3                 :  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
           4                 :  *
           5                 :  * The contents of this file are subject to the Mozilla Public License Version
           6                 :  * 1.1 (the "License"); you may not use this file except in compliance with
           7                 :  * the License. You may obtain a copy of the License at
           8                 :  * http://www.mozilla.org/MPL/
           9                 :  *
          10                 :  * Software distributed under the License is distributed on an "AS IS" basis,
          11                 :  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
          12                 :  * for the specific language governing rights and limitations under the
          13                 :  * License.
          14                 :  *
          15                 :  * The Original Code is mozilla.org code.
          16                 :  *
          17                 :  * The Initial Developer of the Original Code is
          18                 :  * Netscape Communications Corporation.
          19                 :  * Portions created by the Initial Developer are Copyright (C) 2002
          20                 :  * the Initial Developer. All Rights Reserved.
          21                 :  *
          22                 :  * Contributor(s):
          23                 :  *  Brian Ryner <bryner@brianryner.com>
          24                 :  *
          25                 :  * Alternatively, the contents of this file may be used under the terms of
          26                 :  * either the GNU General Public License Version 2 or later (the "GPL"), or
          27                 :  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
          28                 :  * in which case the provisions of the GPL or the LGPL are applicable instead
          29                 :  * of those above. If you wish to allow use of your version of this file only
          30                 :  * under the terms of either the GPL or the LGPL, and not to allow others to
          31                 :  * use your version of this file under the terms of the MPL, indicate your
          32                 :  * decision by deleting the provisions above and replace them with the notice
          33                 :  * and other provisions required by the GPL or the LGPL. If you do not delete
          34                 :  * the provisions above, a recipient may use your version of this file under
          35                 :  * the terms of any one of the MPL, the GPL or the LGPL.
          36                 :  *
          37                 :  * ***** END LICENSE BLOCK ***** */
          38                 :
          39                 : #include "nsXULAppAPI.h"
          40                 : #include "application.ini.h"
          41                 : #include "nsXPCOMGlue.h"
          42                 : #if defined(XP_WIN)
          43                 : #include <windows.h>
          44                 : #include <stdlib.h>
          45                 : #elif defined(XP_UNIX)
          46                 : #include <sys/time.h>
          47                 : #include <sys/resource.h>
          48                 : #endif
          49                 :
          50                 : #ifdef XP_MACOSX
          51                 : #include "MacQuirks.h"
          52                 : #endif
          53                 :
          54                 : #include <stdio.h>
          55                 : #include <stdarg.h>
          56                 :
          57                 : #include "nsCOMPtr.h"
          58                 : #include "nsILocalFile.h"
          59                 : #include "nsStringGlue.h"
          60                 :
          61                 : #ifdef XP_WIN
          62                 : // we want a wmain entry point
          63                 : #include "nsWindowsWMain.cpp"
          64                 : #define snprintf _snprintf
          65                 : #define strcasecmp _stricmp
          66                 : #endif
          67                 : #include "BinaryPath.h"
          68                 :
          69                 : #include "nsXPCOMPrivate.h" // for MAXPATHLEN and XPCOM_DLL
          70                 :
          71                 : #include "mozilla/Telemetry.h"
          72                 :
          73               2 : static void Output(const char *fmt, ... )
          74                 : {
          75                 :   va_list ap;
          76               2 :   va_start(ap, fmt);
          77                 :
          78                 : #if defined(XP_WIN) && !MOZ_WINCONSOLE
          79                 :   PRUnichar msg[2048];
          80                 :   _vsnwprintf(msg, sizeof(msg)/sizeof(msg[0]), NS_ConvertUTF8toUTF16(fmt).get(), ap);
          81                 :   MessageBoxW(NULL, msg, L"XULRunner", MB_OK | MB_ICONERROR);
          82                 : #else
          83               2 :   vfprintf(stderr, fmt, ap);
          84                 : #endif
          85                 :
          86               2 :   va_end(ap);
          87               2 : }
          88                 :
          89                 : /**
          90                 :  * Return true if |arg| matches the given argument name.
          91                 :  */
          92               0 : static bool IsArg(const char* arg, const char* s)
          93                 : {
          94               0 :   if (*arg == '-')
          95                 :   {
          96               0 :     if (*++arg == '-')
          97               0 :       ++arg;
          98               0 :     return !strcasecmp(arg, s);
          99                 :   }
         100                 :
         101                 : #if defined(XP_WIN) || defined(XP_OS2)
         102                 :   if (*arg == '/')
         103                 :     return !strcasecmp(++arg, s);
         104                 : #endif
         105                 :
         106               0 :   return false;
         107                 : }
         108                 :
         109                 : /**
         110                 :  * A helper class which calls NS_LogInit/NS_LogTerm in its scope.
         111                 :  */
         112                 : class ScopedLogging
         113                 : {
         114                 : public:
         115               0 :   ScopedLogging() { NS_LogInit(); }
         116               0 :   ~ScopedLogging() { NS_LogTerm(); }
         117                 : };
         118                 :
         119                 : XRE_GetFileFromPathType XRE_GetFileFromPath;
         120                 : XRE_CreateAppDataType XRE_CreateAppData;
         121                 : XRE_FreeAppDataType XRE_FreeAppData;
         122                 : #ifdef XRE_HAS_DLL_BLOCKLIST
         123                 : XRE_SetupDllBlocklistType XRE_SetupDllBlocklist;
         124                 : #endif
         125                 : XRE_TelemetryAccumulateType XRE_TelemetryAccumulate;
         126                 : XRE_mainType XRE_main;
         127                 :
         128                 : static const nsDynamicFunctionLoad kXULFuncs[] = {
         129                 :     { "XRE_GetFileFromPath", (NSFuncPtr*) &XRE_GetFileFromPath },
         130                 :     { "XRE_CreateAppData", (NSFuncPtr*) &XRE_CreateAppData },
         131                 :     { "XRE_FreeAppData", (NSFuncPtr*) &XRE_FreeAppData },
         132                 : #ifdef XRE_HAS_DLL_BLOCKLIST
         133                 :     { "XRE_SetupDllBlocklist", (NSFuncPtr*) &XRE_SetupDllBlocklist },
         134                 : #endif
         135                 :     { "XRE_TelemetryAccumulate", (NSFuncPtr*) &XRE_TelemetryAccumulate },
         136                 :     { "XRE_main", (NSFuncPtr*) &XRE_main },
         137                 :     { nsnull, nsnull }
         138                 : };
         139                 :
         140               0 : static int do_main(int argc, char* argv[])
         141                 : {
         142               0 :   nsCOMPtr<nsILocalFile> appini;
         143                 :   nsresult rv;
         144                 :
         145                 :   // Allow firefox.exe to launch XULRunner apps via -app <application.ini>
         146                 :   // Note that -app must be the *first* argument.
         147               0 :   const char *appDataFile = getenv("XUL_APP_FILE");
         148               0 :   if (appDataFile && *appDataFile) {
         149               0 :     rv = XRE_GetFileFromPath(appDataFile, getter_AddRefs(appini));
         150               0 :     if (NS_FAILED(rv)) {
         151               0 :       Output("Invalid path found: '%s'", appDataFile);
         152               0 :       return 255;
         153                 :     }
         154                 :   }
         155               0 :   else if (argc > 1 && IsArg(argv[1], "app")) {
         156               0 :     if (argc == 2) {
         157               0 :       Output("Incorrect number of arguments passed to -app");
         158               0 :       return 255;
         159                 :     }
         160                 :
         161               0 :     rv = XRE_GetFileFromPath(argv[2], getter_AddRefs(appini));
         162               0 :     if (NS_FAILED(rv)) {
         163               0 :       Output("application.ini path not recognized: '%s'", argv[2]);
         164               0 :       return 255;
         165                 :     }
         166                 :
         167                 :     char appEnv[MAXPATHLEN];
         168               0 :     snprintf(appEnv, MAXPATHLEN, "XUL_APP_FILE=%s", argv[2]);
         169               0 :     if (putenv(appEnv)) {
         170               0 :       Output("Couldn't set %s.\n", appEnv);
         171               0 :       return 255;
         172                 :     }
         173               0 :     argv[2] = argv[0];
         174               0 :     argv += 2;
         175               0 :     argc -= 2;
         176                 :   }
         177                 :
         178               0 :   if (appini) {
         179                 :     nsXREAppData *appData;
         180               0 :     rv = XRE_CreateAppData(appini, &appData);
         181               0 :     if (NS_FAILED(rv)) {
         182               0 :       Output("Couldn't read application.ini");
         183               0 :       return 255;
         184                 :     }
         185               0 :     int result = XRE_main(argc, argv, appData);
         186               0 :     XRE_FreeAppData(appData);
         187               0 :     return result;
         188                 :   }
         189                 :
         190               0 :   return XRE_main(argc, argv, &sAppData);
         191                 : }
         192                 :
         193               2 : int main(int argc, char* argv[])
         194                 : {
         195                 :   char exePath[MAXPATHLEN];
         196                 :
         197                 : #ifdef XP_MACOSX
         198                 :   TriggerQuirks();
         199                 : #endif
         200                 :
         201               2 :   nsresult rv = mozilla::BinaryPath::Get(argv[0], exePath);
         202               2 :   if (NS_FAILED(rv)) {
         203               0 :     Output("Couldn't calculate the application directory.\n");
         204               0 :     return 255;
         205                 :   }
         206                 :
         207               2 :   char *lastSlash = strrchr(exePath, XPCOM_FILE_PATH_SEPARATOR[0]);
         208               2 :   if (!lastSlash || (size_t(lastSlash - exePath) > MAXPATHLEN - sizeof(XPCOM_DLL) - 1))
         209               0 :     return 255;
         210                 :
         211               2 :   strcpy(++lastSlash, XPCOM_DLL);
         212                 :
         213                 :   int gotCounters;
         214                 : #if defined(XP_UNIX)
         215                 :   struct rusage initialRUsage;
         216               2 :   gotCounters = !getrusage(RUSAGE_SELF, &initialRUsage);
         217                 : #elif defined(XP_WIN)
         218                 :   // GetProcessIoCounters().ReadOperationCount seems to have little to
         219                 :   // do with actual read operations. It reports 0 or 1 at this stage
         220                 :   // in the program. Luckily 1 coincides with when prefetch is
         221                 :   // enabled. If Windows prefetch didn't happen we can do our own
         222                 :   // faster dll preloading.
         223                 :   IO_COUNTERS ioCounters;
         224                 :   gotCounters = GetProcessIoCounters(GetCurrentProcess(), &ioCounters);
         225                 :   if (gotCounters && !ioCounters.ReadOperationCount)
         226                 : #endif
         227                 :   {
         228               2 :       XPCOMGlueEnablePreload();
         229                 :   }
         230                 :
         231                 :
         232               2 :   rv = XPCOMGlueStartup(exePath);
         233               2 :   if (NS_FAILED(rv)) {
         234               2 :     Output("Couldn't load XPCOM.\n");
         235               2 :     return 255;
         236                 :   }
         237                 :   // Reset exePath so that it is the directory name and not the xpcom dll name
         238               0 :   *lastSlash = 0;
         239                 :
         240               0 :   rv = XPCOMGlueLoadXULFunctions(kXULFuncs);
         241               0 :   if (NS_FAILED(rv)) {
         242               0 :     Output("Couldn't load XRE functions.\n");
         243               0 :     return 255;
         244                 :   }
         245                 :
         246                 : #ifdef XRE_HAS_DLL_BLOCKLIST
         247                 :   XRE_SetupDllBlocklist();
         248                 : #endif
         249                 :
         250               0 :   if (gotCounters) {
         251                 : #if defined(XP_WIN)
         252                 :     XRE_TelemetryAccumulate(mozilla::Telemetry::EARLY_GLUESTARTUP_READ_OPS,
         253                 :                             int(ioCounters.ReadOperationCount));
         254                 :     XRE_TelemetryAccumulate(mozilla::Telemetry::EARLY_GLUESTARTUP_READ_TRANSFER,
         255                 :                             int(ioCounters.ReadTransferCount / 1024));
         256                 :     IO_COUNTERS newIoCounters;
         257                 :     if (GetProcessIoCounters(GetCurrentProcess(), &newIoCounters)) {
         258                 :       XRE_TelemetryAccumulate(mozilla::Telemetry::GLUESTARTUP_READ_OPS,
         259                 :                               int(newIoCounters.ReadOperationCount - ioCounters.ReadOperationCount));
         260                 :       XRE_TelemetryAccumulate(mozilla::Telemetry::GLUESTARTUP_READ_TRANSFER,
         261                 :                               int((newIoCounters.ReadTransferCount - ioCounters.ReadTransferCount) / 1024));
         262                 :     }
         263                 : #elif defined(XP_UNIX)
         264                 :     XRE_TelemetryAccumulate(mozilla::Telemetry::EARLY_GLUESTARTUP_HARD_FAULTS,
         265               0 :                             int(initialRUsage.ru_majflt));
         266                 :     struct rusage newRUsage;
         267               0 :     if (!getrusage(RUSAGE_SELF, &newRUsage)) {
         268                 :       XRE_TelemetryAccumulate(mozilla::Telemetry::GLUESTARTUP_HARD_FAULTS,
         269               0 :                               int(newRUsage.ru_majflt - initialRUsage.ru_majflt));
         270                 :     }
         271                 : #endif
         272                 :   }
         273                 :
         274                 :   int result;
         275                 :   {
         276               0 :     ScopedLogging log;
         277               0 :     result = do_main(argc, argv);
         278                 :   }
         279                 :
         280               0 :   XPCOMGlueShutdown();
         281               0 :   return result;
         282                 : }

Generated by: LCOV version 1.7