/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- *//* ***** BEGIN LICENSE BLOCK ***** * Version: MPL 1.1/GPL 2.0/LGPL 2.1 * * The contents of this file are subject to the Mozilla Public License Version * 1.1 (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * http://www.mozilla.org/MPL/ * * Software distributed under the License is distributed on an "AS IS" basis, * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License * for the specific language governing rights and limitations under the * License. * * The Original Code is Mozilla Communicator client code. This file was split * from xpfe/appshell/src/nsAppShellService.cpp * * The Initial Developer of the Original Code is * Netscape Communications Corporation. * Portions created by the Initial Developer are Copyright (C) 1998 * the Initial Developer. All Rights Reserved. * * Contributor(s): * Pierre Phaneuf <pp@ludusdesign.com> * Robert O'Callahan <roc+moz@cs.cmu.edu> * Benjamin Smedberg <bsmedberg@covad.net> * Daniel Brooks <db48x@db48x.net> * Taras Glek <tglek@mozilla.com> * Landry Breuil <landry@openbsd.org> * David Rajchenbach-Teller <dteller@mozilla.com> * * Alternatively, the contents of this file may be used under the terms of * either of the GNU General Public License Version 2 or later (the "GPL"), * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), * in which case the provisions of the GPL or the LGPL are applicable instead * of those above. If you wish to allow use of your version of this file only * under the terms of either the GPL or the LGPL, and not to allow others to * use your version of this file under the terms of the MPL, indicate your * decision by deleting the provisions above and replace them with the notice * and other provisions required by the GPL or the LGPL. If you do not delete * the provisions above, a recipient may use your version of this file under * the terms of any one of the MPL, the GPL or the LGPL. * * ***** END LICENSE BLOCK ***** */#include"nsAppStartup.h"#include"nsIAppShellService.h"#include"nsPIDOMWindow.h"#include"nsIInterfaceRequestor.h"#include"nsILocalFile.h"#include"nsIObserverService.h"#include"nsIPrefBranch.h"#include"nsIPrefService.h"#include"nsIProfileChangeStatus.h"#include"nsIPromptService.h"#include"nsIStringBundle.h"#include"nsISupportsPrimitives.h"#include"nsIWebBrowserChrome.h"#include"nsIWindowMediator.h"#include"nsIWindowWatcher.h"#include"nsIXULWindow.h"#include"nsNativeCharsetUtils.h"#include"nsThreadUtils.h"#include"nsAutoPtr.h"#include"nsStringGlue.h"#include"prprf.h"#include"nsCRT.h"#include"nsIInterfaceRequestorUtils.h"#include"nsWidgetsCID.h"#include"nsAppShellCID.h"#include"mozilla/Services.h"#include"mozilla/FunctionTimer.h"#include"nsIXPConnect.h"#include"jsapi.h"#include"prenv.h"#if defined(XP_WIN)#include<windows.h>// windows.h can go to hell #undef GetStartupInfo#elif defined(XP_UNIX)#include<unistd.h>#include<sys/syscall.h>#endif#ifdef XP_MACOSX#include<sys/sysctl.h>#endif#ifdef __OpenBSD__#include<sys/param.h>#include<sys/sysctl.h>#endif#include"mozilla/Telemetry.h"#include"mozilla/StartupTimeline.h"staticNS_DEFINE_CID(kAppShellCID,NS_APPSHELL_CID);#if defined(XP_WIN)#include"mozilla/perfprobe.h"/** * Events sent to the system for profiling purposes *///Keep them syncronized with the .mof file//Process-wide GUID, used by the OS to differentiate sources// {509962E0-406B-46F4-99BA-5A009F8D2225}//Keep it synchronized with the .mof file#define NS_APPLICATION_TRACING_CID \ { 0x509962E0, 0x406B, 0x46F4, \ { 0x99, 0xBA, 0x5A, 0x00, 0x9F, 0x8D, 0x22, 0x25} }//Event-specific GUIDs, used by the OS to differentiate events// {A3DA04E0-57D7-482A-A1C1-61DA5F95BACB}#define NS_PLACES_INIT_COMPLETE_EVENT_CID \ { 0xA3DA04E0, 0x57D7, 0x482A, \ { 0xA1, 0xC1, 0x61, 0xDA, 0x5F, 0x95, 0xBA, 0xCB} }// {917B96B1-ECAD-4DAB-A760-8D49027748AE}#define NS_SESSION_STORE_WINDOW_RESTORED_EVENT_CID \ { 0x917B96B1, 0xECAD, 0x4DAB, \ { 0xA7, 0x60, 0x8D, 0x49, 0x02, 0x77, 0x48, 0xAE} }staticNS_DEFINE_CID(kApplicationTracingCID,NS_APPLICATION_TRACING_CID);staticNS_DEFINE_CID(kPlacesInitCompleteCID,NS_PLACES_INIT_COMPLETE_EVENT_CID);staticNS_DEFINE_CID(kSessionStoreWindowRestoredCID,NS_SESSION_STORE_WINDOW_RESTORED_EVENT_CID);#endif //defined(XP_WIN)usingnamespacemozilla;PRUint32gRestartMode=0;classnsAppExitEvent:publicnsRunnable{private:nsRefPtr<nsAppStartup>mService;public:nsAppExitEvent(nsAppStartup*service):mService(service){}NS_IMETHODRun(){// Tell the appshell to exitmService->mAppShell->Exit();// We're done "shutting down".mService->mShuttingDown=false;mService->mRunning=false;returnNS_OK;}};//// nsAppStartup//nsAppStartup::nsAppStartup():mConsiderQuitStopper(0),mRunning(false),mShuttingDown(false),mAttemptingQuit(false),mRestart(false),mInterrupted(false){}nsresultnsAppStartup::Init(){NS_TIME_FUNCTION;nsresultrv;// Create widget application shellmAppShell=do_GetService(kAppShellCID,&rv);NS_ENSURE_SUCCESS(rv,rv);NS_TIME_FUNCTION_MARK("Got AppShell service");nsCOMPtr<nsIObserverService>os=mozilla::services::GetObserverService();if(!os)returnNS_ERROR_FAILURE;NS_TIME_FUNCTION_MARK("Got Observer service");os->AddObserver(this,"quit-application-forced",true);os->AddObserver(this,"sessionstore-windows-restored",true);os->AddObserver(this,"profile-change-teardown",true);os->AddObserver(this,"xul-window-registered",true);os->AddObserver(this,"xul-window-destroyed",true);#if defined(XP_WIN)os->AddObserver(this,"places-init-complete",true);// This last event is only interesting to us for xperf-based measures// Initialize interaction with profilermProbesManager=newProbeManager(kApplicationTracingCID,NS_LITERAL_CSTRING("Application startup probe"));// Note: The operation is meant mostly for in-house profiling.// Therefore, we do not warn if probes manager cannot be initializedif(mProbesManager){mPlacesInitCompleteProbe=mProbesManager->GetProbe(kPlacesInitCompleteCID,NS_LITERAL_CSTRING("places-init-complete"));NS_WARN_IF_FALSE(mPlacesInitCompleteProbe,"Cannot initialize probe 'places-init-complete'");mSessionWindowRestoredProbe=mProbesManager->GetProbe(kSessionStoreWindowRestoredCID,NS_LITERAL_CSTRING("sessionstore-windows-restored"));NS_WARN_IF_FALSE(mSessionWindowRestoredProbe,"Cannot initialize probe 'sessionstore-windows-restored'");rv=mProbesManager->StartSession();NS_WARN_IF_FALSE(NS_SUCCEEDED(rv),"Cannot initialize system probe manager");}#endif //defined(XP_WIN)returnNS_OK;}//// nsAppStartup->nsISupports//NS_IMPL_THREADSAFE_ISUPPORTS5(nsAppStartup,nsIAppStartup,nsIWindowCreator,nsIWindowCreator2,nsIObserver,nsISupportsWeakReference)//// nsAppStartup->nsIAppStartup//NS_IMETHODIMPnsAppStartup::CreateHiddenWindow(){nsCOMPtr<nsIAppShellService>appShellService(do_GetService(NS_APPSHELLSERVICE_CONTRACTID));NS_ENSURE_TRUE(appShellService,NS_ERROR_FAILURE);returnappShellService->CreateHiddenWindow();}NS_IMETHODIMPnsAppStartup::DestroyHiddenWindow(){nsCOMPtr<nsIAppShellService>appShellService(do_GetService(NS_APPSHELLSERVICE_CONTRACTID));NS_ENSURE_TRUE(appShellService,NS_ERROR_FAILURE);returnappShellService->DestroyHiddenWindow();}NS_IMETHODIMPnsAppStartup::Run(void){NS_ASSERTION(!mRunning,"Reentrant appstartup->Run()");// If we have no windows open and no explicit calls to// enterLastWindowClosingSurvivalArea, or somebody has explicitly called// quit, don't bother running the event loop which would probably leave us// with a zombie process.if(!mShuttingDown&&mConsiderQuitStopper!=0){#ifdef XP_MACOSXEnterLastWindowClosingSurvivalArea();#endifmRunning=true;nsresultrv=mAppShell->Run();if(NS_FAILED(rv))returnrv;}returnmRestart?NS_SUCCESS_RESTART_APP:NS_OK;}NS_IMETHODIMPnsAppStartup::Quit(PRUint32aMode){PRUint32ferocity=(aMode&0xF);// Quit the application. We will asynchronously call the appshell's// Exit() method via nsAppExitEvent to allow one last pass// through any events in the queue. This guarantees a tidy cleanup.nsresultrv=NS_OK;boolpostedExitEvent=false;if(mShuttingDown)returnNS_OK;// If we're considering quitting, we will only do so if:if(ferocity==eConsiderQuit){if(mConsiderQuitStopper==0){// there are no windows...ferocity=eAttemptQuit;}#ifdef XP_MACOSXelseif(mConsiderQuitStopper==1){// ... or there is only a hiddenWindow left, and it's useless:nsCOMPtr<nsIAppShellService>appShell(do_GetService(NS_APPSHELLSERVICE_CONTRACTID));// Failure shouldn't be fatal, but will abort quit attempt:if(!appShell)returnNS_OK;boolusefulHiddenWindow;appShell->GetApplicationProvidedHiddenWindow(&usefulHiddenWindow);nsCOMPtr<nsIXULWindow>hiddenWindow;appShell->GetHiddenWindow(getter_AddRefs(hiddenWindow));// If the one window is useful, we won't quit:if(!hiddenWindow||usefulHiddenWindow)returnNS_OK;ferocity=eAttemptQuit;}#endif}nsCOMPtr<nsIObserverService>obsService;if(ferocity==eAttemptQuit||ferocity==eForceQuit){nsCOMPtr<nsISimpleEnumerator>windowEnumerator;nsCOMPtr<nsIWindowMediator>mediator(do_GetService(NS_WINDOWMEDIATOR_CONTRACTID));if(mediator){mediator->GetEnumerator(nsnull,getter_AddRefs(windowEnumerator));if(windowEnumerator){boolmore;while(windowEnumerator->HasMoreElements(&more),more){nsCOMPtr<nsISupports>window;windowEnumerator->GetNext(getter_AddRefs(window));nsCOMPtr<nsPIDOMWindow>domWindow(do_QueryInterface(window));if(domWindow){if(!domWindow->CanClose())returnNS_OK;}}}}mShuttingDown=true;if(!mRestart){mRestart=(aMode&eRestart)!=0;gRestartMode=(aMode&0xF0);}if(mRestart){// Firefox-restarts reuse the process. Process start-time isn't a useful indicator of startup timePR_SetEnv(PR_smprintf("MOZ_APP_RESTART=%lld",(PRInt64)PR_Now()/PR_USEC_PER_MSEC));}obsService=mozilla::services::GetObserverService();if(!mAttemptingQuit){mAttemptingQuit=true;#ifdef XP_MACOSX// now even the Mac wants to quit when the last window is closedExitLastWindowClosingSurvivalArea();#endifif(obsService)obsService->NotifyObservers(nsnull,"quit-application-granted",nsnull);}/* Enumerate through each open window and close it. It's important to do this before we forcequit because this can control whether we really quit at all. e.g. if one of these windows has an unload handler that opens a new window. Ugh. I know. */CloseAllWindows();if(mediator){if(ferocity==eAttemptQuit){ferocity=eForceQuit;// assume success/* Were we able to immediately close all windows? if not, eAttemptQuit failed. This could happen for a variety of reasons; in fact it's very likely. Perhaps we're being called from JS and the window->Close method hasn't had a chance to wrap itself up yet. So give up. We'll return (with eConsiderQuit) as the remaining windows are closed. */mediator->GetEnumerator(nsnull,getter_AddRefs(windowEnumerator));if(windowEnumerator){boolmore;while(windowEnumerator->HasMoreElements(&more),more){/* we can't quit immediately. we'll try again as the last window finally closes. */ferocity=eAttemptQuit;nsCOMPtr<nsISupports>window;windowEnumerator->GetNext(getter_AddRefs(window));nsCOMPtr<nsIDOMWindow>domWindow=do_QueryInterface(window);if(domWindow){boolclosed=false;domWindow->GetClosed(&closed);if(!closed){rv=NS_ERROR_FAILURE;break;}}}}}}}if(ferocity==eForceQuit){// do it!// No chance of the shutdown being cancelled from here on; tell people// we're shutting down for sure while all services are still available.if(obsService){NS_NAMED_LITERAL_STRING(shutdownStr,"shutdown");NS_NAMED_LITERAL_STRING(restartStr,"restart");obsService->NotifyObservers(nsnull,"quit-application",mRestart?restartStr.get():shutdownStr.get());}if(!mRunning){postedExitEvent=true;}else{// no matter what, make sure we send the exit event. If// worst comes to worst, we'll do a leaky shutdown but we WILL// shut down. Well, assuming that all *this* stuff works ;-).nsCOMPtr<nsIRunnable>event=newnsAppExitEvent(this);rv=NS_DispatchToCurrentThread(event);if(NS_SUCCEEDED(rv)){postedExitEvent=true;}else{NS_WARNING("failed to dispatch nsAppExitEvent");}}}// turn off the reentrancy check flag, but not if we have// more asynchronous work to do still.if(!postedExitEvent)mShuttingDown=false;returnrv;}voidnsAppStartup::CloseAllWindows(){nsCOMPtr<nsIWindowMediator>mediator(do_GetService(NS_WINDOWMEDIATOR_CONTRACTID));nsCOMPtr<nsISimpleEnumerator>windowEnumerator;mediator->GetEnumerator(nsnull,getter_AddRefs(windowEnumerator));if(!windowEnumerator)return;boolmore;while(NS_SUCCEEDED(windowEnumerator->HasMoreElements(&more))&&more){nsCOMPtr<nsISupports>isupports;if(NS_FAILED(windowEnumerator->GetNext(getter_AddRefs(isupports))))break;nsCOMPtr<nsPIDOMWindow>window=do_QueryInterface(isupports);NS_ASSERTION(window,"not an nsPIDOMWindow");if(window)window->ForceClose();}}NS_IMETHODIMPnsAppStartup::EnterLastWindowClosingSurvivalArea(void){++mConsiderQuitStopper;returnNS_OK;}NS_IMETHODIMPnsAppStartup::ExitLastWindowClosingSurvivalArea(void){NS_ASSERTION(mConsiderQuitStopper>0,"consider quit stopper out of bounds");--mConsiderQuitStopper;if(mRunning)Quit(eConsiderQuit);returnNS_OK;}//// nsAppStartup->nsIAppStartup2//NS_IMETHODIMPnsAppStartup::GetShuttingDown(bool*aResult){*aResult=mShuttingDown;returnNS_OK;}NS_IMETHODIMPnsAppStartup::SetInterrupted(boolaInterrupted){mInterrupted=aInterrupted;returnNS_OK;}NS_IMETHODIMPnsAppStartup::GetInterrupted(bool*aInterrupted){*aInterrupted=mInterrupted;returnNS_OK;}//// nsAppStartup->nsIWindowCreator//NS_IMETHODIMPnsAppStartup::CreateChromeWindow(nsIWebBrowserChrome*aParent,PRUint32aChromeFlags,nsIWebBrowserChrome**_retval){boolcancel;returnCreateChromeWindow2(aParent,aChromeFlags,0,0,&cancel,_retval);}//// nsAppStartup->nsIWindowCreator2//NS_IMETHODIMPnsAppStartup::CreateChromeWindow2(nsIWebBrowserChrome*aParent,PRUint32aChromeFlags,PRUint32aContextFlags,nsIURI*aURI,bool*aCancel,nsIWebBrowserChrome**_retval){NS_ENSURE_ARG_POINTER(aCancel);NS_ENSURE_ARG_POINTER(_retval);*aCancel=false;*_retval=0;// Non-modal windows cannot be opened if we are attempting to quitif(mAttemptingQuit&&(aChromeFlags&nsIWebBrowserChrome::CHROME_MODAL)==0)returnNS_ERROR_ILLEGAL_DURING_SHUTDOWN;nsCOMPtr<nsIXULWindow>newWindow;if(aParent){nsCOMPtr<nsIXULWindow>xulParent(do_GetInterface(aParent));NS_ASSERTION(xulParent,"window created using non-XUL parent. that's unexpected, but may work.");if(xulParent)xulParent->CreateNewWindow(aChromeFlags,getter_AddRefs(newWindow));// And if it fails, don't try again without a parent. It could fail// intentionally (bug 115969).}else{// try using basic methods:/* You really shouldn't be making dependent windows without a parent. But unparented modal (and therefore dependent) windows happen in our codebase, so we allow it after some bellyaching: */if(aChromeFlags&nsIWebBrowserChrome::CHROME_DEPENDENT)NS_WARNING("dependent window created without a parent");nsCOMPtr<nsIAppShellService>appShell(do_GetService(NS_APPSHELLSERVICE_CONTRACTID));if(!appShell)returnNS_ERROR_FAILURE;appShell->CreateTopLevelWindow(0,0,aChromeFlags,nsIAppShellService::SIZE_TO_CONTENT,nsIAppShellService::SIZE_TO_CONTENT,getter_AddRefs(newWindow));}// if anybody gave us anything to work with, use itif(newWindow){newWindow->SetContextFlags(aContextFlags);nsCOMPtr<nsIInterfaceRequestor>thing(do_QueryInterface(newWindow));if(thing)CallGetInterface(thing.get(),_retval);}return*_retval?NS_OK:NS_ERROR_FAILURE;}//// nsAppStartup->nsIObserver//NS_IMETHODIMPnsAppStartup::Observe(nsISupports*aSubject,constchar*aTopic,constPRUnichar*aData){NS_ASSERTION(mAppShell,"appshell service notified before appshell built");if(!strcmp(aTopic,"quit-application-forced")){mShuttingDown=true;}elseif(!strcmp(aTopic,"profile-change-teardown")){if(!mShuttingDown){EnterLastWindowClosingSurvivalArea();CloseAllWindows();ExitLastWindowClosingSurvivalArea();}}elseif(!strcmp(aTopic,"xul-window-registered")){EnterLastWindowClosingSurvivalArea();}elseif(!strcmp(aTopic,"xul-window-destroyed")){ExitLastWindowClosingSurvivalArea();}elseif(!strcmp(aTopic,"sessionstore-windows-restored")){StartupTimeline::Record(StartupTimeline::SESSION_RESTORED);#if defined(XP_WIN)if(mSessionWindowRestoredProbe){mSessionWindowRestoredProbe->Trigger();}}elseif(!strcmp(aTopic,"places-init-complete")){if(mPlacesInitCompleteProbe){mPlacesInitCompleteProbe->Trigger();}#endif //defined(XP_WIN)}else{NS_ERROR("Unexpected observer topic.");}returnNS_OK;}#if defined(LINUX) || defined(ANDROID)staticPRUint64JiffiesSinceBoot(constchar*file){charstat[512];FILE*f=fopen(file,"r");if(!f)return0;intn=fread(&stat,1,sizeof(stat)-1,f);fclose(f);if(n<=0)return0;stat[n]=0;longlongunsignedstarttime=0;// instead of PRUint64 to keep GCC quietchar*s=strrchr(stat,')');if(!s)return0;intret=sscanf(s+2,"%*c %*d %*d %*d %*d %*d %*u %*u %*u %*u ""%*u %*u %*u %*u %*u %*d %*d %*d %*d %llu",&starttime);if(ret!=1||!starttime)return0;returnstarttime;}staticvoidThreadedCalculateProcessCreationTimestamp(void*aClosure){PRTimenow=PR_Now();longhz=sysconf(_SC_CLK_TCK);if(!hz)return;charthread_stat[40];sprintf(thread_stat,"/proc/self/task/%d/stat",(pid_t)syscall(__NR_gettid));PRUint64thread_jiffies=JiffiesSinceBoot(thread_stat);PRUint64self_jiffies=JiffiesSinceBoot("/proc/self/stat");if(!thread_jiffies||!self_jiffies)return;PRTimeinterval=(thread_jiffies-self_jiffies)*PR_USEC_PER_SEC/hz;StartupTimeline::Record(StartupTimeline::PROCESS_CREATION,now-interval);}staticPRTimeCalculateProcessCreationTimestamp(){PRThread*thread=PR_CreateThread(PR_USER_THREAD,ThreadedCalculateProcessCreationTimestamp,NULL,PR_PRIORITY_NORMAL,PR_LOCAL_THREAD,PR_JOINABLE_THREAD,0);PR_JoinThread(thread);returnStartupTimeline::Get(StartupTimeline::PROCESS_CREATION);}#elif defined(XP_WIN)staticPRTimeCalculateProcessCreationTimestamp(){FILETIMEstart,foo,bar,baz;boolsuccess=GetProcessTimes(GetCurrentProcess(),&start,&foo,&bar,&baz);if(!success)return0;// copied from NSPR _PR_FileTimeToPRTimePRUint64timestamp=0;CopyMemory(×tamp,&start,sizeof(PRTime));#ifdef __GNUC__timestamp=(timestamp-116444736000000000LL)/10LL;#elsetimestamp=(timestamp-116444736000000000i64)/10i64;#endifreturntimestamp;}#elif defined(XP_MACOSX)staticPRTimeCalculateProcessCreationTimestamp(){intmib[4]={CTL_KERN,KERN_PROC,KERN_PROC_PID,getpid()};size_tbuffer_size;if(sysctl(mib,4,NULL,&buffer_size,NULL,0))return0;structkinfo_proc*proc=(kinfo_proc*)malloc(buffer_size);if(sysctl(mib,4,proc,&buffer_size,NULL,0)){free(proc);return0;}PRTimestarttime=static_cast<PRTime>(proc->kp_proc.p_un.__p_starttime.tv_sec)*PR_USEC_PER_SEC;starttime+=proc->kp_proc.p_un.__p_starttime.tv_usec;free(proc);returnstarttime;}#elif defined(__OpenBSD__)staticPRTimeCalculateProcessCreationTimestamp(){intmib[6]={CTL_KERN,KERN_PROC,KERN_PROC_PID,getpid(),sizeof(structkinfo_proc),1};size_tbuffer_size;if(sysctl(mib,6,NULL,&buffer_size,NULL,0))return0;structkinfo_proc*proc=(structkinfo_proc*)malloc(buffer_size);if(sysctl(mib,6,proc,&buffer_size,NULL,0)){free(proc);return0;}PRTimestarttime=static_cast<PRTime>(proc->p_ustart_sec)*PR_USEC_PER_SEC;starttime+=proc->p_ustart_usec;free(proc);returnstarttime;}#elsestaticPRTimeCalculateProcessCreationTimestamp(){return0;}#endifNS_IMETHODIMPnsAppStartup::GetStartupInfo(JSContext*aCx,JS::Value*aRetval){JSObject*obj=JS_NewObject(aCx,NULL,NULL,NULL);*aRetval=OBJECT_TO_JSVAL(obj);PRTimeProcessCreationTimestamp=StartupTimeline::Get(StartupTimeline::PROCESS_CREATION);if(!ProcessCreationTimestamp){char*moz_app_restart=PR_GetEnv("MOZ_APP_RESTART");if(moz_app_restart){ProcessCreationTimestamp=nsCRT::atoll(moz_app_restart)*PR_USEC_PER_MSEC;}else{ProcessCreationTimestamp=CalculateProcessCreationTimestamp();}// Bug 670008: Avoid obviously invalid process creation timesif(PR_Now()<=ProcessCreationTimestamp){ProcessCreationTimestamp=-1;Telemetry::Accumulate(Telemetry::STARTUP_MEASUREMENT_ERRORS,StartupTimeline::PROCESS_CREATION);}StartupTimeline::Record(StartupTimeline::PROCESS_CREATION,ProcessCreationTimestamp);}for(inti=StartupTimeline::PROCESS_CREATION;i<StartupTimeline::MAX_EVENT_ID;++i){StartupTimeline::Eventev=static_cast<StartupTimeline::Event>(i);if(StartupTimeline::Get(ev)>0){// always define main to aid with bug 689256if((ev!=StartupTimeline::MAIN)&&(StartupTimeline::Get(ev)<StartupTimeline::Get(StartupTimeline::PROCESS_CREATION))){Telemetry::Accumulate(Telemetry::STARTUP_MEASUREMENT_ERRORS,i);StartupTimeline::Record(ev,-1);}else{JSObject*date=JS_NewDateObjectMsec(aCx,StartupTimeline::Get(ev)/PR_USEC_PER_MSEC);JS_DefineProperty(aCx,obj,StartupTimeline::Describe(ev),OBJECT_TO_JSVAL(date),NULL,NULL,JSPROP_ENUMERATE);}}}returnNS_OK;}