sw/source/core/docnode/finalthreadmanager.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: finalthreadmanager.cxx,v $
  10  * $Revision: 1.3 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30 #include "precompiled_sw.hxx"
  31 #include <finalthreadmanager.hxx>
  32
  33 #ifndef _OSL_THREAD_HXX_
  34 #include <osl/thread.hxx>
  35 #endif
  36 #include <errhdl.hxx>
  37 #include <pausethreadstarting.hxx>
  38 #include <swthreadjoiner.hxx>
  39
  40 #include <com/sun/star/frame/XDesktop.hpp>
  41 #include <rtl/ustring.hxx>
  42 #include <com/sun/star/frame/XFramesSupplier.hpp>
  43
  44 namespace css = ::com::sun::star;
  45
  46 /** thread to cancel a give list of cancellable jobs
  47
  48     helper class for FinalThreadManager
  49
  50     @author OD
  51 */
  52 class CancelJobsThread : public osl::Thread
  53 {
  54     public:
  55         CancelJobsThread( std::list< css::uno::Reference< css::util::XCancellable > > aJobs )
  56             : osl::Thread(),
  57               maMutex(),
  58               maJobs( aJobs ),
  59               mbAllJobsCancelled( false ),
  60               mbStopped( false )
  61         {
  62         }
  63
  64         virtual ~CancelJobsThread() {}
  65
  66         void addJobs( std::list< css::uno::Reference< css::util::XCancellable > >& rJobs );
  67
  68         bool allJobsCancelled() const;
  69
  70         void stopWhenAllJobsCancelled();
  71
  72     private:
  73
  74         bool existJobs() const;
  75
  76         css::uno::Reference< css::util::XCancellable > getNextJob();
  77
  78         bool stopped() const;
  79
  80         virtual void SAL_CALL run();
  81
  82         mutable osl::Mutex maMutex;
  83
  84         std::list< css::uno::Reference< css::util::XCancellable > > maJobs;
  85
  86         bool mbAllJobsCancelled;
  87         bool mbStopped;
  88 };
  89
  90 void CancelJobsThread::addJobs( std::list< css::uno::Reference< css::util::XCancellable > >& rJobs )
  91 {
  92     osl::MutexGuard aGuard(maMutex);
  93
  94     maJobs.insert( maJobs.end(), rJobs.begin(), rJobs.end() );
  95     mbAllJobsCancelled = !maJobs.empty();
  96 }
  97
  98 bool CancelJobsThread::existJobs() const
  99 {
 100     osl::MutexGuard aGuard(maMutex);
 101
 102     return !maJobs.empty();
 103 }
 104
 105 bool CancelJobsThread::allJobsCancelled() const
 106 {
 107     osl::MutexGuard aGuard(maMutex);
 108
 109     return maJobs.empty() && mbAllJobsCancelled;
 110 }
 111 void CancelJobsThread::stopWhenAllJobsCancelled()
 112 {
 113     osl::MutexGuard aGuard(maMutex);
 114
 115     mbStopped = true;
 116 }
 117
 118 css::uno::Reference< css::util::XCancellable > CancelJobsThread::getNextJob()
 119 {
 120     css::uno::Reference< css::util::XCancellable > xRet;
 121
 122     {
 123         osl::MutexGuard aGuard(maMutex);
 124
 125         if ( !maJobs.empty() )
 126         {
 127             xRet = maJobs.front();
 128             maJobs.pop_front();
 129         }
 130     }
 131
 132     return xRet;
 133 }
 134
 135 bool CancelJobsThread::stopped() const
 136 {
 137     osl::MutexGuard aGuard(maMutex);
 138
 139     return mbStopped;
 140 }
 141
 142 void SAL_CALL CancelJobsThread::run()
 143 {
 144     while ( !stopped() )
 145     {
 146         while ( existJobs() )
 147         {
 148             css::uno::Reference< css::util::XCancellable > aJob( getNextJob() );
 149             if ( aJob.is() )
 150             {
 151                 aJob->cancel();
 152             }
 153         }
 154
 155         mbAllJobsCancelled = true;
 156
 157         {
 158             TimeValue aSleepTime;
 159             aSleepTime.Seconds = 1;
 160             aSleepTime.Nanosec = 0;
 161             osl_waitThread( &aSleepTime );
 162         }
 163     }
 164 }
 165
 166 /** thread to terminate office, when all jobs are cancelled.
 167
 168     helper class for FinalThreadManager
 169
 170     @author OD
 171 */
 172 class TerminateOfficeThread : public osl::Thread
 173 {
 174     public:
 175         TerminateOfficeThread( CancelJobsThread& rCancelJobsThread,
 176                                css::uno::Reference< css::uno::XComponentContext > const & xContext )
 177             : osl::Thread(),
 178               maMutex(),
 179               mrCancelJobsThread( rCancelJobsThread ),
 180               mbStopOfficeTermination( false ),
 181               mxContext( xContext )
 182         {
 183         }
 184
 185         virtual ~TerminateOfficeThread() {}
 186
 187         void StopOfficeTermination();
 188
 189     private:
 190
 191         virtual void SAL_CALL run();
 192         virtual void SAL_CALL onTerminated();
 193
 194         bool OfficeTerminationStopped();
 195
 196         void PerformOfficeTermination();
 197
 198         osl::Mutex maMutex;
 199
 200         const CancelJobsThread& mrCancelJobsThread;
 201
 202         bool mbStopOfficeTermination;
 203
 204         css::uno::Reference< css::uno::XComponentContext > mxContext;
 205 };
 206
 207 void TerminateOfficeThread::StopOfficeTermination()
 208 {
 209     osl::MutexGuard aGuard(maMutex);
 210
 211     mbStopOfficeTermination = true;
 212 }
 213
 214 bool TerminateOfficeThread::OfficeTerminationStopped()
 215 {
 216     osl::MutexGuard aGuard(maMutex);
 217
 218     return mbStopOfficeTermination;
 219 }
 220
 221 void SAL_CALL TerminateOfficeThread::run()
 222 {
 223     while ( !OfficeTerminationStopped() )
 224     {
 225         osl::MutexGuard aGuard(maMutex);
 226
 227         if ( mrCancelJobsThread.allJobsCancelled() )
 228         {
 229             break;
 230         }
 231     }
 232
 233     if ( !OfficeTerminationStopped() )
 234     {
 235         PerformOfficeTermination();
 236     }
 237 }
 238
 239 void TerminateOfficeThread::PerformOfficeTermination()
 240 {
 241     css::uno::Reference< css::frame::XFramesSupplier > xTasksSupplier(
 242         mxContext->getServiceManager()->createInstanceWithContext(
 243             ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.frame.Desktop") ),
 244             mxContext ),
 245         css::uno::UNO_QUERY );
 246     if ( !xTasksSupplier.is() )
 247     {
 248         ASSERT( false, "<TerminateOfficeThread::PerformOfficeTermination()> - no XFramesSupplier!" );
 249         return;
 250     }
 251
 252     css::uno::Reference< css::container::XElementAccess > xList( xTasksSupplier->getFrames(), css::uno::UNO_QUERY );
 253     if ( !xList.is() )
 254     {
 255         ASSERT( false, "<TerminateOfficeThread::PerformOfficeTermination()> - no XElementAccess!" );
 256         return;
 257     }
 258
 259     if ( !xList->hasElements() )
 260     {
 261         css::uno::Reference< css::frame::XDesktop > xDesktop( xTasksSupplier, css::uno::UNO_QUERY );
 262         if ( xDesktop.is() && !OfficeTerminationStopped() )
 263         {
 264             xDesktop->terminate();
 265         }
 266     }
 267 }
 268
 269 void SAL_CALL TerminateOfficeThread::onTerminated()
 270 {
 271     if ( OfficeTerminationStopped() )
 272     {
 273         delete this;
 274     }
 275 }
 276
 277
 278 /** class FinalThreadManager
 279
 280     @author OD
 281 */
 282 FinalThreadManager::FinalThreadManager(css::uno::Reference< css::uno::XComponentContext > const & context)
 283     : m_xContext(context),
 284       maMutex(),
 285       maThreads(),
 286       mpCancelJobsThread( 0 ),
 287       mpTerminateOfficeThread( 0 ),
 288       mpPauseThreadStarting( 0 ),
 289       mbRegisteredAtDesktop( false )
 290 {
 291
 292 }
 293
 294 void FinalThreadManager::registerAsListenerAtDesktop()
 295 {
 296     css::uno::Reference< css::frame::XDesktop > xDesktop(
 297         m_xContext->getServiceManager()->createInstanceWithContext(
 298             ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.frame.Desktop") ),
 299             m_xContext ),
 300         css::uno::UNO_QUERY );
 301
 302     if ( xDesktop.is() )
 303     {
 304         xDesktop->addTerminateListener( css::uno::Reference< css::frame::XTerminateListener >( static_cast< cppu::OWeakObject* >( this ), css::uno::UNO_QUERY ) );
 305     }
 306 }
 307
 308 FinalThreadManager::~FinalThreadManager()
 309 {
 310     if ( mpPauseThreadStarting != 0 )
 311     {
 312         delete mpPauseThreadStarting;
 313         mpPauseThreadStarting = 0;
 314     }
 315
 316     if ( mpTerminateOfficeThread != 0 )
 317     {
 318         mpTerminateOfficeThread->StopOfficeTermination(); // thread kills itself.
 319         mpTerminateOfficeThread = 0;
 320     }
 321
 322     if ( !maThreads.empty() )
 323     {
 324         ASSERT( false, "<FinalThreadManager::~FinalThreadManager()> - still registered jobs are existing -> perform cancellation" );
 325         cancelAllJobs();
 326     }
 327
 328     if ( mpCancelJobsThread != 0 )
 329     {
 330         if ( !mpCancelJobsThread->allJobsCancelled() )
 331         {
 332             ASSERT( false, "<FinalThreadManager::~FinalThreadManager()> - cancellation of registered jobs not yet finished -> wait for its finish" );
 333         }
 334
 335         mpCancelJobsThread->stopWhenAllJobsCancelled();
 336         mpCancelJobsThread->join();
 337         delete mpCancelJobsThread;
 338         mpCancelJobsThread = 0;
 339     }
 340 }
 341
 342 // com.sun.star.uno.XServiceInfo:
 343 ::rtl::OUString SAL_CALL FinalThreadManager::getImplementationName() throw (css::uno::RuntimeException)
 344 {
 345     return comp_FinalThreadManager::_getImplementationName();
 346 }
 347
 348 ::sal_Bool SAL_CALL FinalThreadManager::supportsService(::rtl::OUString const & serviceName) throw (css::uno::RuntimeException)
 349 {
 350     css::uno::Sequence< ::rtl::OUString > serviceNames = comp_FinalThreadManager::_getSupportedServiceNames();
 351     for (::sal_Int32 i = 0; i < serviceNames.getLength(); ++i) {
 352         if (serviceNames[i] == serviceName)
 353             return sal_True;
 354     }
 355     return sal_False;
 356 }
 357
 358 css::uno::Sequence< ::rtl::OUString > SAL_CALL FinalThreadManager::getSupportedServiceNames() throw (css::uno::RuntimeException)
 359 {
 360     return comp_FinalThreadManager::_getSupportedServiceNames();
 361 }
 362
 363 // ::com::sun::star::util::XJobManager:
 364 void SAL_CALL FinalThreadManager::registerJob(const css::uno::Reference< css::util::XCancellable > & Job) throw (css::uno::RuntimeException)
 365 {
 366     osl::MutexGuard aGuard(maMutex);
 367
 368     maThreads.push_back( Job );
 369
 370     if ( !mbRegisteredAtDesktop )
 371     {
 372         registerAsListenerAtDesktop();
 373         mbRegisteredAtDesktop = true;
 374     }
 375 }
 376
 377 void SAL_CALL FinalThreadManager::releaseJob(const css::uno::Reference< css::util::XCancellable > & Job) throw (css::uno::RuntimeException)
 378 {
 379     osl::MutexGuard aGuard(maMutex);
 380
 381     maThreads.remove( Job );
 382 }
 383
 384 void SAL_CALL FinalThreadManager::cancelAllJobs() throw (css::uno::RuntimeException)
 385 {
 386     std::list< css::uno::Reference< css::util::XCancellable > > aThreads;
 387     {
 388         osl::MutexGuard aGuard(maMutex);
 389
 390         aThreads.insert( aThreads.end(), maThreads.begin(), maThreads.end() );
 391         maThreads.clear();
 392     }
 393
 394     if ( !aThreads.empty() )
 395     {
 396         osl::MutexGuard aGuard(maMutex);
 397
 398         if ( mpCancelJobsThread == 0 )
 399         {
 400             mpCancelJobsThread = new CancelJobsThread( aThreads );;
 401             if ( !mpCancelJobsThread->create() )
 402             {
 403                 // error handling
 404                 // ASSERT( false, "<FinalThreadManager::cancelAllJobs()> - thread to cancel jobs can't be setup --> synchron cancellation of jobs" );
 405                 delete mpCancelJobsThread;
 406                 mpCancelJobsThread = 0;
 407                 while ( !aThreads.empty() )
 408                 {
 409                     aThreads.front()->cancel();
 410                     aThreads.pop_front();
 411                 }
 412             }
 413         }
 414         else
 415         {
 416             mpCancelJobsThread->addJobs( aThreads );
 417         }
 418     }
 419 }
 420
 421 // ::com::sun::star::frame::XTerminateListener
 422 void SAL_CALL FinalThreadManager::queryTermination( const css::lang::EventObject& ) throw (css::frame::TerminationVetoException, css::uno::RuntimeException)
 423 {
 424     osl::MutexGuard aGuard(maMutex);
 425
 426     cancelAllJobs();
 427     // Sleep 1 second to give the thread for job cancellation some time.
 428     // Probably, all started threads have already finished its work.
 429     if ( mpCancelJobsThread != 0 &&
 430          !mpCancelJobsThread->allJobsCancelled() )
 431     {
 432         TimeValue aSleepTime;
 433         aSleepTime.Seconds = 1;
 434         aSleepTime.Nanosec = 0;
 435         osl_waitThread( &aSleepTime );
 436     }
 437
 438     if ( mpCancelJobsThread != 0 &&
 439          !mpCancelJobsThread->allJobsCancelled() )
 440     {
 441         if ( mpTerminateOfficeThread != 0 )
 442         {
 443             if ( mpTerminateOfficeThread->isRunning() )
 444             {
 445                 mpTerminateOfficeThread->StopOfficeTermination(); // thread kills itself.
 446             }
 447             else
 448             {
 449                 delete mpTerminateOfficeThread;
 450             }
 451             mpTerminateOfficeThread = 0;
 452         }
 453         mpTerminateOfficeThread = new TerminateOfficeThread( *mpCancelJobsThread,
 454                                                  m_xContext );
 455         if ( !mpTerminateOfficeThread->create() )
 456         {
 457             // ASSERT( false, "FinalThreadManager::queryTermination(..) - thread to terminate office can't be started!" );
 458             delete mpTerminateOfficeThread;
 459             mpTerminateOfficeThread = 0;
 460         }
 461
 462         throw css::frame::TerminationVetoException();
 463     }
 464
 465     mpPauseThreadStarting = new SwPauseThreadStarting();
 466
 467     return;
 468 }
 469
 470 void SAL_CALL FinalThreadManager::cancelTermination( const css::lang::EventObject& ) throw (css::uno::RuntimeException)
 471 {
 472     if ( mpPauseThreadStarting != 0 )
 473     {
 474         delete mpPauseThreadStarting;
 475         mpPauseThreadStarting = 0;
 476     }
 477
 478     return;
 479 }
 480
 481 void SAL_CALL FinalThreadManager::notifyTermination( const css::lang::EventObject& ) throw (css::uno::RuntimeException)
 482 {
 483     if ( mpTerminateOfficeThread != 0 )
 484     {
 485         if ( mpTerminateOfficeThread->isRunning() )
 486         {
 487             // ASSERT( false, "<FinalThreadManager::notifyTermination()> - office termination thread still running!" );
 488             mpTerminateOfficeThread->StopOfficeTermination(); // thread kills itself.
 489         }
 490         else
 491         {
 492             delete mpTerminateOfficeThread;
 493         }
 494         mpTerminateOfficeThread = 0;
 495     }
 496
 497     if ( !maThreads.empty() )
 498     {
 499         // ASSERT( false, "<FinalThreadManager::notifyTermination()> - still registered jobs are existing" );
 500         cancelAllJobs();
 501     }
 502
 503     if ( mpCancelJobsThread != 0 )
 504     {
 505         if ( !mpCancelJobsThread->allJobsCancelled() )
 506         {
 507             // ASSERT( false, "<FinalThreadManager::notifyTermination()> - cancellation of registered jobs not yet finished -> wait for its finish" );
 508         }
 509
 510         mpCancelJobsThread->stopWhenAllJobsCancelled();
 511         mpCancelJobsThread->join();
 512         delete mpCancelJobsThread;
 513         mpCancelJobsThread = 0;
 514     }
 515
 516     // get reference of this
 517     css::uno::Reference< css::uno::XInterface > aOwnRef( static_cast< cppu::OWeakObject* >( this ));
 518     // notify <SwThreadJoiner> to release its reference
 519     SwThreadJoiner::ReleaseThreadJoiner();
 520 }
 521
 522 // ::com::sun:star::lang::XEventListener (inherited via com::sun::star::frame::XTerminateListener)
 523 void SAL_CALL FinalThreadManager::disposing( const css::lang::EventObject& ) throw (css::uno::RuntimeException)
 524 {
 525     // nothing to do, because instance doesn't hold any references of observed objects
 526 }
 527
 528 // component helper namespace
 529 namespace comp_FinalThreadManager {
 530
 531     ::rtl::OUString SAL_CALL _getImplementationName()
 532     {
 533         return ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(
 534             "com.sun.star.util.comp.FinalThreadManager"));
 535     }
 536
 537     css::uno::Sequence< ::rtl::OUString > SAL_CALL _getSupportedServiceNames()
 538     {
 539         css::uno::Sequence< ::rtl::OUString > s(1);
 540         s[0] = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(
 541             "com.sun.star.util.JobManager"));
 542         return s;
 543     }
 544
 545     css::uno::Reference< css::uno::XInterface > SAL_CALL _create(
 546         const css::uno::Reference< css::uno::XComponentContext > & context)
 547             SAL_THROW((css::uno::Exception))
 548     {
 549         return static_cast< ::cppu::OWeakObject * >(new FinalThreadManager(context));
 550     }
 551
 552 } // closing component helper namespace