gecko-dev/dom/ipc/MemoryReportRequest.cpp

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "MemoryReportRequest.h"
#include "mozilla/Unused.h"
#include "mozilla/dom/ContentChild.h"
#include "mozilla/gfx/GPUParent.h"

namespace mozilla {
namespace dom {

MemoryReportRequestHost::MemoryReportRequestHost(uint32_t aGeneration)
  : mGeneration(aGeneration),
    mSuccess(false)
{
  MOZ_COUNT_CTOR(MemoryReportRequestHost);
  mReporterManager = nsMemoryReporterManager::GetOrCreate();
  NS_WARNING_ASSERTION(mReporterManager, "GetOrCreate failed");
}

void
MemoryReportRequestHost::RecvReport(const MemoryReport& aReport)
{
  // Skip reports from older generations. We need to do this here since we
  // could receive older reports from a subprocesses before it acknowledges
  // a new request, and we only track one active request per process.
  if (aReport.generation() != mGeneration) {
    return;
  }

  if (mReporterManager) {
    mReporterManager->HandleChildReport(mGeneration, aReport);
  }
}

void
MemoryReportRequestHost::Finish(uint32_t aGeneration)
{
  // Skip reports from older generations. See the comment in RecvReport.
  if (mGeneration != aGeneration) {
    return;
  }
  mSuccess = true;
}

MemoryReportRequestHost::~MemoryReportRequestHost()
{
  MOZ_COUNT_DTOR(MemoryReportRequestHost);

  if (mReporterManager) {
    mReporterManager->EndProcessReport(mGeneration, mSuccess);
    mReporterManager = nullptr;
  }
}

NS_IMPL_ISUPPORTS(MemoryReportRequestClient, nsIRunnable)

/* static */ void
MemoryReportRequestClient::Start(uint32_t aGeneration,
                                 bool aAnonymize,
                                 bool aMinimizeMemoryUsage,
                                 const MaybeFileDesc& aDMDFile,
                                 const nsACString& aProcessString)
{
  RefPtr<MemoryReportRequestClient> request = new MemoryReportRequestClient(
    aGeneration,
    aAnonymize,
    aDMDFile,
    aProcessString);

  DebugOnly<nsresult> rv;
  if (aMinimizeMemoryUsage) {
    nsCOMPtr<nsIMemoryReporterManager> mgr =
      do_GetService("@mozilla.org/memory-reporter-manager;1");
    rv = mgr->MinimizeMemoryUsage(request);
    // mgr will eventually call actor->Run()
  } else {
    rv = request->Run();
  }

  NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "actor operation failed");
}

MemoryReportRequestClient::MemoryReportRequestClient(uint32_t aGeneration,
                                                     bool aAnonymize,
                                                     const MaybeFileDesc& aDMDFile,
                                                     const nsACString& aProcessString)
 : mGeneration(aGeneration),
   mAnonymize(aAnonymize),
   mProcessString(aProcessString)
{
  if (aDMDFile.type() == MaybeFileDesc::TFileDescriptor) {
    mDMDFile = aDMDFile.get_FileDescriptor();
  }
}

MemoryReportRequestClient::~MemoryReportRequestClient()
{
}

class HandleReportCallback final : public nsIHandleReportCallback
{
public:
  NS_DECL_ISUPPORTS

  explicit HandleReportCallback(uint32_t aGeneration,
                                const nsACString& aProcess)
  : mGeneration(aGeneration)
  , mProcess(aProcess)
  { }

  NS_IMETHOD Callback(const nsACString& aProcess, const nsACString &aPath,
                      int32_t aKind, int32_t aUnits, int64_t aAmount,
                      const nsACString& aDescription,
                      nsISupports* aUnused) override
  {
    MemoryReport memreport(mProcess, nsCString(aPath), aKind, aUnits,
                           aAmount, mGeneration, nsCString(aDescription));
    switch (XRE_GetProcessType()) {
      case GeckoProcessType_Content:
        ContentChild::GetSingleton()->SendAddMemoryReport(memreport);
        break;
      case GeckoProcessType_GPU:
        Unused << gfx::GPUParent::GetSingleton()->SendAddMemoryReport(memreport);
        break;
      default:
        MOZ_ASSERT_UNREACHABLE("Unhandled process type");
    }
    return NS_OK;
  }
private:
  ~HandleReportCallback() = default;

  uint32_t mGeneration;
  const nsCString mProcess;
};

NS_IMPL_ISUPPORTS(
  HandleReportCallback
, nsIHandleReportCallback
)

class FinishReportingCallback final : public nsIFinishReportingCallback
{
public:
  NS_DECL_ISUPPORTS

  explicit FinishReportingCallback(uint32_t aGeneration)
  : mGeneration(aGeneration)
  {
  }

  NS_IMETHOD Callback(nsISupports* aUnused) override
  {
    bool sent = false;
    switch (XRE_GetProcessType()) {
      case GeckoProcessType_Content:
        sent = ContentChild::GetSingleton()->SendFinishMemoryReport(mGeneration);
        break;
      case GeckoProcessType_GPU:
        sent = gfx::GPUParent::GetSingleton()->SendFinishMemoryReport(mGeneration);
        break;
      default:
        MOZ_ASSERT_UNREACHABLE("Unhandled process type");
    }
    return sent ? NS_OK : NS_ERROR_FAILURE;
  }

private:
  ~FinishReportingCallback() = default;

  uint32_t mGeneration;
};

NS_IMPL_ISUPPORTS(
  FinishReportingCallback
, nsIFinishReportingCallback
)

NS_IMETHODIMP MemoryReportRequestClient::Run()
{
  nsCOMPtr<nsIMemoryReporterManager> mgr =
    do_GetService("@mozilla.org/memory-reporter-manager;1");

  // Run the reporters.  The callback will turn each measurement into a
  // MemoryReport.
  RefPtr<HandleReportCallback> handleReport =
    new HandleReportCallback(mGeneration, mProcessString);
  RefPtr<FinishReportingCallback> finishReporting =
    new FinishReportingCallback(mGeneration);

  nsresult rv =
    mgr->GetReportsForThisProcessExtended(handleReport, nullptr, mAnonymize,
                                          FileDescriptorToFILE(mDMDFile, "wb"),
                                          finishReporting, nullptr);
  NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
                       "GetReportsForThisProcessExtended failed");
  return rv;
}

} // namespace dom
} // namespace mozilla