dom/ipc/ContentProcessParent.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /* vim: set sw=4 ts=8 et tw=80 : */
   3 /* ***** BEGIN LICENSE BLOCK *****
   4  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   5  *
   6  * The contents of this file are subject to the Mozilla Public License Version
   7  * 1.1 (the "License"); you may not use this file except in compliance with
   8  * the License. You may obtain a copy of the License at
   9  * http://www.mozilla.org/MPL/
  10  *
  11  * Software distributed under the License is distributed on an "AS IS" basis,
  12  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  13  * for the specific language governing rights and limitations under the
  14  * License.
  15  *
  16  * The Original Code is Mozilla Content App.
  17  *
  18  * The Initial Developer of the Original Code is
  19  *   The Mozilla Foundation.
  20  * Portions created by the Initial Developer are Copyright (C) 2009
  21  * the Initial Developer. All Rights Reserved.
  22  *
  23  * Contributor(s):
  24  *   Frederic Plourde <frederic.plourde@collabora.co.uk>
  25  *
  26  * Alternatively, the contents of this file may be used under the terms of
  27  * either the GNU General Public License Version 2 or later (the "GPL"), or
  28  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  29  * in which case the provisions of the GPL or the LGPL are applicable instead
  30  * of those above. If you wish to allow use of your version of this file only
  31  * under the terms of either the GPL or the LGPL, and not to allow others to
  32  * use your version of this file under the terms of the MPL, indicate your
  33  * decision by deleting the provisions above and replace them with the notice
  34  * and other provisions required by the GPL or the LGPL. If you do not delete
  35  * the provisions above, a recipient may use your version of this file under
  36  * the terms of any one of the MPL, the GPL or the LGPL.
  37  *
  38  * ***** END LICENSE BLOCK ***** */
  39
  40 #include "ContentProcessParent.h"
  41
  42 #include "TabParent.h"
  43 #include "mozilla/ipc/TestShellParent.h"
  44 #include "mozilla/net/NeckoParent.h"
  45 #include "nsIPrefBranch.h"
  46 #include "nsIPrefBranch2.h"
  47 #include "nsIPrefLocalizedString.h"
  48 #include "nsIObserverService.h"
  49
  50 #include "nsAutoPtr.h"
  51 #include "nsCOMPtr.h"
  52 #include "nsServiceManagerUtils.h"
  53 #include "nsThreadUtils.h"
  54 #include "nsChromeRegistryChrome.h"
  55
  56 using namespace mozilla::ipc;
  57 using namespace mozilla::net;
  58 using mozilla::MonitorAutoEnter;
  59
  60 namespace mozilla {
  61 namespace dom {
  62
  63 #define NS_IPC_IOSERVICE_SET_OFFLINE_TOPIC "ipc:network:set-offline"
  64
  65 ContentProcessParent* ContentProcessParent::gSingleton;
  66
  67 ContentProcessParent*
  68 ContentProcessParent::GetSingleton(PRBool aForceNew)
  69 {
  70     if (gSingleton && !gSingleton->IsAlive())
  71         gSingleton = nsnull;
  72
  73     if (!gSingleton && aForceNew) {
  74         nsRefPtr<ContentProcessParent> parent = new ContentProcessParent();
  75         if (parent) {
  76             nsCOMPtr<nsIObserverService> obs =
  77                 do_GetService("@mozilla.org/observer-service;1");
  78             if (obs) {
  79                 if (NS_SUCCEEDED(obs->AddObserver(parent, "xpcom-shutdown",
  80                                                   PR_FALSE))) {
  81                     gSingleton = parent;
  82                     nsCOMPtr<nsIPrefBranch2> prefs
  83                         (do_GetService(NS_PREFSERVICE_CONTRACTID));
  84                     if (prefs) {
  85                         prefs->AddObserver("", parent, PR_FALSE);
  86                     }
  87                 }
  88                 obs->AddObserver(
  89                   parent, NS_IPC_IOSERVICE_SET_OFFLINE_TOPIC, PR_FALSE);
  90             }
  91             nsCOMPtr<nsIThreadInternal>
  92                 threadInt(do_QueryInterface(NS_GetCurrentThread()));
  93             if (threadInt) {
  94                 threadInt->GetObserver(getter_AddRefs(parent->mOldObserver));
  95                 threadInt->SetObserver(parent);
  96             }
  97         }
  98     }
  99     return gSingleton;
 100 }
 101
 102 void
 103 ContentProcessParent::ActorDestroy(ActorDestroyReason why)
 104 {
 105     nsCOMPtr<nsIThreadObserver>
 106         kungFuDeathGrip(static_cast<nsIThreadObserver*>(this));
 107     nsCOMPtr<nsIObserverService>
 108         obs(do_GetService("@mozilla.org/observer-service;1"));
 109     if (obs)
 110         obs->RemoveObserver(static_cast<nsIObserver*>(this), "xpcom-shutdown");
 111     nsCOMPtr<nsIThreadInternal>
 112         threadInt(do_QueryInterface(NS_GetCurrentThread()));
 113     if (threadInt)
 114         threadInt->SetObserver(mOldObserver);
 115     if (mRunToCompletionDepth)
 116         mRunToCompletionDepth = 0;
 117
 118     mIsAlive = false;
 119 }
 120
 121 TabParent*
 122 ContentProcessParent::CreateTab()
 123 {
 124   return static_cast<TabParent*>(SendPIFrameEmbeddingConstructor());
 125 }
 126
 127 TestShellParent*
 128 ContentProcessParent::CreateTestShell()
 129 {
 130   return static_cast<TestShellParent*>(SendPTestShellConstructor());
 131 }
 132
 133 bool
 134 ContentProcessParent::DestroyTestShell(TestShellParent* aTestShell)
 135 {
 136     return PTestShellParent::Send__delete__(aTestShell);
 137 }
 138
 139 ContentProcessParent::ContentProcessParent()
 140     : mMonitor("ContentProcessParent::mMonitor")
 141     , mRunToCompletionDepth(0)
 142     , mShouldCallUnblockChild(false)
 143     , mIsAlive(true)
 144 {
 145     NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 146     mSubprocess = new GeckoChildProcessHost(GeckoProcessType_Content);
 147     mSubprocess->AsyncLaunch();
 148     Open(mSubprocess->GetChannel(), mSubprocess->GetChildProcessHandle());
 149
 150     nsCOMPtr<nsIChromeRegistry> registrySvc = nsChromeRegistry::GetService();
 151     nsChromeRegistryChrome* chromeRegistry =
 152         static_cast<nsChromeRegistryChrome*>(registrySvc.get());
 153     chromeRegistry->SendRegisteredChrome(this);
 154 }
 155
 156 ContentProcessParent::~ContentProcessParent()
 157 {
 158     NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 159     //If the previous content process has died, a new one could have
 160     //been started since.
 161     if (gSingleton == this)
 162         gSingleton = nsnull;
 163 }
 164
 165 bool
 166 ContentProcessParent::IsAlive()
 167 {
 168     return mIsAlive;
 169 }
 170
 171 bool
 172 ContentProcessParent::RecvGetPrefType(const nsCString& prefName,
 173                                       PRInt32* retValue, nsresult* rv)
 174 {
 175     *retValue = 0;
 176
 177     EnsurePrefService();
 178     *rv = mPrefService->GetPrefType(prefName.get(), retValue);
 179     return true;
 180 }
 181
 182 bool
 183 ContentProcessParent::RecvGetBoolPref(const nsCString& prefName,
 184                                       PRBool* retValue, nsresult* rv)
 185 {
 186     *retValue = PR_FALSE;
 187
 188     EnsurePrefService();
 189     *rv = mPrefService->GetBoolPref(prefName.get(), retValue);
 190     return true;
 191 }
 192
 193 bool
 194 ContentProcessParent::RecvGetIntPref(const nsCString& prefName,
 195                                      PRInt32* retValue, nsresult* rv)
 196 {
 197     *retValue = 0;
 198
 199     EnsurePrefService();
 200     *rv = mPrefService->GetIntPref(prefName.get(), retValue);
 201     return true;
 202 }
 203
 204 bool
 205 ContentProcessParent::RecvGetCharPref(const nsCString& prefName,
 206                                       nsCString* retValue, nsresult* rv)
 207 {
 208     EnsurePrefService();
 209     *rv = mPrefService->GetCharPref(prefName.get(), getter_Copies(*retValue));
 210     return true;
 211 }
 212
 213 bool
 214 ContentProcessParent::RecvGetPrefLocalizedString(const nsCString& prefName,
 215                                                  nsString* retValue, nsresult* rv)
 216 {
 217     EnsurePrefService();
 218     nsCOMPtr<nsIPrefLocalizedString> string;
 219     *rv = mPrefService->GetComplexValue(prefName.get(),
 220             NS_GET_IID(nsIPrefLocalizedString), getter_AddRefs(string));
 221
 222     if (NS_SUCCEEDED(*rv))
 223       string->GetData(getter_Copies(*retValue));
 224
 225     return true;
 226 }
 227
 228 bool
 229 ContentProcessParent::RecvPrefHasUserValue(const nsCString& prefName,
 230                                            PRBool* retValue, nsresult* rv)
 231 {
 232     *retValue = PR_FALSE;
 233
 234     EnsurePrefService();
 235     *rv = mPrefService->PrefHasUserValue(prefName.get(), retValue);
 236     return true;
 237 }
 238
 239 bool
 240 ContentProcessParent::RecvPrefIsLocked(const nsCString& prefName,
 241                                        PRBool* retValue, nsresult* rv)
 242 {
 243     *retValue = PR_FALSE;
 244
 245     EnsurePrefService();
 246     *rv = mPrefService->PrefIsLocked(prefName.get(), retValue);
 247
 248     return true;
 249 }
 250
 251 bool
 252 ContentProcessParent::RecvGetChildList(const nsCString& domain,
 253                                        nsTArray<nsCString>* list, nsresult* rv)
 254 {
 255     EnsurePrefService();
 256
 257     PRUint32 count;
 258     char **childArray;
 259     *rv = mPrefService->GetChildList(domain.get(), &count, &childArray);
 260
 261     if (NS_SUCCEEDED(*rv)) {
 262       list->SetCapacity(count);
 263       for (PRUint32 i = 0; i < count; ++i)
 264         *(list->AppendElement()) = childArray[i];
 265     }
 266
 267     return true;
 268 }
 269
 270 void
 271 ContentProcessParent::EnsurePrefService()
 272 {
 273     nsresult rv;
 274     if (!mPrefService) {
 275         mPrefService = do_GetService(NS_PREFSERVICE_CONTRACTID, &rv);
 276         NS_ASSERTION(NS_SUCCEEDED(rv),
 277                      "We lost prefService in the Chrome process !");
 278     }
 279 }
 280
 281 NS_IMPL_THREADSAFE_ISUPPORTS2(ContentProcessParent,
 282                               nsIObserver,
 283                               nsIThreadObserver)
 284
 285 namespace {
 286 void
 287 DeleteSubprocess(GeckoChildProcessHost* aSubprocess)
 288 {
 289     delete aSubprocess;
 290 }
 291 }
 292
 293 NS_IMETHODIMP
 294 ContentProcessParent::Observe(nsISupports* aSubject,
 295                               const char* aTopic,
 296                               const PRUnichar* aData)
 297 {
 298     if (!strcmp(aTopic, "xpcom-shutdown") && mSubprocess) {
 299         // remove the global remote preferences observers
 300         nsCOMPtr<nsIPrefBranch2> prefs
 301             (do_GetService(NS_PREFSERVICE_CONTRACTID));
 302         if (prefs) {
 303             if (gSingleton) {
 304                 prefs->RemoveObserver("", this);
 305             }
 306         }
 307
 308         Close();
 309         XRE_GetIOMessageLoop()->PostTask(
 310             FROM_HERE,
 311             NewRunnableFunction(DeleteSubprocess, mSubprocess));
 312         mSubprocess = nsnull;
 313     }
 314
 315     // listening for remotePrefs...
 316     if (!strcmp(aTopic, "nsPref:changed")) {
 317         // We know prefs are ASCII here.
 318         NS_LossyConvertUTF16toASCII strData(aData);
 319         if (mIsAlive)
 320             SendNotifyRemotePrefObserver(strData);
 321     }
 322
 323     if (!strcmp(aTopic, NS_IPC_IOSERVICE_SET_OFFLINE_TOPIC) && mSubprocess) {
 324       NS_ConvertUTF16toUTF8 dataStr(aData);
 325       const char *offline = dataStr.get();
 326       if (mIsAlive)
 327           SendSetOffline(!strcmp(offline, "true") ? true : false);
 328     }
 329     return NS_OK;
 330 }
 331
 332 PIFrameEmbeddingParent*
 333 ContentProcessParent::AllocPIFrameEmbedding()
 334 {
 335   TabParent* parent = new TabParent();
 336   if (parent){
 337     NS_ADDREF(parent);
 338   }
 339   return parent;
 340 }
 341
 342 bool
 343 ContentProcessParent::DeallocPIFrameEmbedding(PIFrameEmbeddingParent* frame)
 344 {
 345   TabParent* parent = static_cast<TabParent*>(frame);
 346   NS_RELEASE(parent);
 347   return true;
 348 }
 349
 350 PTestShellParent*
 351 ContentProcessParent::AllocPTestShell()
 352 {
 353   return new TestShellParent();
 354 }
 355
 356 bool
 357 ContentProcessParent::DeallocPTestShell(PTestShellParent* shell)
 358 {
 359   delete shell;
 360   return true;
 361 }
 362
 363 PNeckoParent*
 364 ContentProcessParent::AllocPNecko()
 365 {
 366     return new NeckoParent();
 367 }
 368
 369 bool
 370 ContentProcessParent::DeallocPNecko(PNeckoParent* necko)
 371 {
 372     delete necko;
 373     return true;
 374 }
 375
 376 void
 377 ContentProcessParent::ReportChildAlreadyBlocked()
 378 {
 379     if (!mRunToCompletionDepth) {
 380 #ifdef DEBUG
 381         printf("Running to completion...\n");
 382 #endif
 383         mRunToCompletionDepth = 1;
 384         mShouldCallUnblockChild = false;
 385     }
 386 }
 387
 388 bool
 389 ContentProcessParent::RequestRunToCompletion()
 390 {
 391     if (!mRunToCompletionDepth &&
 392         BlockChild()) {
 393 #ifdef DEBUG
 394         printf("Running to completion...\n");
 395 #endif
 396         mRunToCompletionDepth = 1;
 397         mShouldCallUnblockChild = true;
 398     }
 399     return !!mRunToCompletionDepth;
 400 }
 401
 402 /* void onDispatchedEvent (in nsIThreadInternal thread); */
 403 NS_IMETHODIMP
 404 ContentProcessParent::OnDispatchedEvent(nsIThreadInternal *thread)
 405 {
 406     if (mOldObserver)
 407         return mOldObserver->OnDispatchedEvent(thread);
 408
 409     return NS_OK;
 410 }
 411
 412 /* void onProcessNextEvent (in nsIThreadInternal thread, in boolean mayWait, in unsigned long recursionDepth); */
 413 NS_IMETHODIMP
 414 ContentProcessParent::OnProcessNextEvent(nsIThreadInternal *thread,
 415                                          PRBool mayWait,
 416                                          PRUint32 recursionDepth)
 417 {
 418     if (mRunToCompletionDepth)
 419         ++mRunToCompletionDepth;
 420
 421     if (mOldObserver)
 422         return mOldObserver->OnProcessNextEvent(thread, mayWait, recursionDepth);
 423
 424     return NS_OK;
 425 }
 426
 427 /* void afterProcessNextEvent (in nsIThreadInternal thread, in unsigned long recursionDepth); */
 428 NS_IMETHODIMP
 429 ContentProcessParent::AfterProcessNextEvent(nsIThreadInternal *thread,
 430                                             PRUint32 recursionDepth)
 431 {
 432     if (mRunToCompletionDepth &&
 433         !--mRunToCompletionDepth) {
 434 #ifdef DEBUG
 435             printf("... ran to completion.\n");
 436 #endif
 437             if (mShouldCallUnblockChild) {
 438                 mShouldCallUnblockChild = false;
 439                 UnblockChild();
 440             }
 441     }
 442
 443     if (mOldObserver)
 444         return mOldObserver->AfterProcessNextEvent(thread, recursionDepth);
 445
 446     return NS_OK;
 447 }
 448
 449 } // namespace dom
 450 } // namespace mozilla