Move CrashService class to breakpad component

components/breakpad/tools/crash_service.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "chrome/tools/crash_service/crash_service.h"
+#include "components/breakpad/tools/crash_service.h"
 
 #include <windows.h>
 
 #include <sddl.h>
 #include <fstream>
 #include <map>
 
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/logging.h"
-#include "base/path_service.h"
 #include "base/win/windows_version.h"
 #include "breakpad/src/client/windows/crash_generation/client_info.h"
 #include "breakpad/src/client/windows/crash_generation/crash_generation_server.h"
 #include "breakpad/src/client/windows/sender/crash_report_sender.h"
-#include "chrome/common/chrome_constants.h"
-#include "chrome/common/chrome_paths.h"
+
+namespace breakpad {
 
 namespace {
 
 const wchar_t kTestPipeName[] = L"\\\\.\\pipe\\ChromeCrashServices";
 
 const wchar_t kCrashReportURL[] = L"https://clients2.google.com/cr/report";
 const wchar_t kCheckPointFile[] = L"crash_checkpoint.txt";
 
 typedef std::map<std::wstring, std::wstring> CrashMap;
 
@@ skipping 112 matching lines @@
 
 }  // namespace
 
 // Command line switches:
 const char CrashService::kMaxReports[]        = "max-reports";
 const char CrashService::kNoWindow[]          = "no-window";
 const char CrashService::kReporterTag[]       = "reporter";
 const char CrashService::kDumpsDir[]          = "dumps-dir";
 const char CrashService::kPipeName[]          = "pipe-name";
 
-CrashService::CrashService(const std::wstring& report_dir)
-    : report_path_(report_dir),
-      sender_(NULL),
+CrashService::CrashService()
+    : sender_(NULL),
       dumper_(NULL),
       requests_handled_(0),
       requests_sent_(0),
       clients_connected_(0),
       clients_terminated_(0) {
-  chrome::RegisterPathProvider();
 }
 
 CrashService::~CrashService() {
   base::AutoLock lock(sending_);
   delete dumper_;
   delete sender_;
 }
 
-
-bool CrashService::Initialize(const std::wstring& command_line) {
+bool CrashService::Initialize(const base::FilePath& operating_dir,
+                              const base::FilePath& report_path,

[Robert Sesek, 2013/10/17 17:21:21]

This doesn't match the signature in the other file.

+                              const base::FilePath& dumps_path) {
   using google_breakpad::CrashReportSender;
   using google_breakpad::CrashGenerationServer;
 
   std::wstring pipe_name = kTestPipeName;
   int max_reports = -1;
 
   // The checkpoint file allows CrashReportSender to enforce the the maximum
   // reports per day quota. Does not seem to serve any other purpose.
-  base::FilePath checkpoint_path = report_path_.Append(kCheckPointFile);
+  base::FilePath checkpoint_path = operating_dir.Append(kCheckPointFile);
 
-  // The dumps path is typically : '<user profile>\Local settings\
-  // Application data\Goggle\Chrome\Crash Reports' and the report path is
-  // Application data\Google\Chrome\Reported Crashes.txt
-  base::FilePath user_data_dir;
-  if (!PathService::Get(chrome::DIR_USER_DATA, &user_data_dir)) {
-    LOG(ERROR) << "could not get DIR_USER_DATA";
-    return false;
-  }
-  report_path_ = user_data_dir.Append(chrome::kCrashReportLog);
+  CommandLine& cmd_line = *CommandLine::ForCurrentProcess();
 
-  CommandLine cmd_line = CommandLine::FromString(command_line);
+  base::FilePath dumps_path_to_use = dumps_path;
 
-  base::FilePath dumps_path;
   if (cmd_line.HasSwitch(kDumpsDir)) {
-    dumps_path = base::FilePath(cmd_line.GetSwitchValueNative(kDumpsDir));
-  } else {
-    if (!PathService::Get(chrome::DIR_CRASH_DUMPS, &dumps_path)) {
-      LOG(ERROR) << "could not get DIR_CRASH_DUMPS";
-      return false;
-    }
+    dumps_path_to_use =
+        base::FilePath(cmd_line.GetSwitchValueNative(kDumpsDir));
   }
 
   // We can override the send reports quota with a command line switch.
   if (cmd_line.HasSwitch(kMaxReports))
     max_reports = _wtoi(cmd_line.GetSwitchValueNative(kMaxReports).c_str());
 
   // Allow the global pipe name to be overridden for better testability.
   if (cmd_line.HasSwitch(kPipeName))
     pipe_name = cmd_line.GetSwitchValueNative(kPipeName);
 
@@ skipping 22 matching lines @@
 
     security_attributes_actual = &security_attributes;
   }
 
   // Create the OOP crash generator object.
   dumper_ = new CrashGenerationServer(pipe_name, security_attributes_actual,
                                       &CrashService::OnClientConnected, this,
                                       &CrashService::OnClientDumpRequest, this,
                                       &CrashService::OnClientExited, this,
                                       NULL, NULL,
-                                      true, &dumps_path.value());
+                                      true, &dumps_path_to_use.value());
 
   if (!dumper_) {
     LOG(ERROR) << "could not create dumper";
     if (security_attributes.lpSecurityDescriptor)
       LocalFree(security_attributes.lpSecurityDescriptor);
     return false;
   }
 
   if (!CreateTopWindow(::GetModuleHandleW(NULL),
                        !cmd_line.HasSwitch(kNoWindow))) {
     LOG(ERROR) << "could not create window";
     if (security_attributes.lpSecurityDescriptor)
       LocalFree(security_attributes.lpSecurityDescriptor);
     return false;
   }
 
   reporter_tag_ = L"crash svc";
   if (cmd_line.HasSwitch(kReporterTag))
     reporter_tag_ = cmd_line.GetSwitchValueNative(kReporterTag);
 
   // Log basic information.
   VLOG(1) << "pipe name is " << pipe_name
-          << "\ndumps at " << dumps_path.value()
-          << "\nreports at " << report_path_.value();
+          << "\ndumps at " << dumps_path_to_use.value();
 
   if (sender_) {
     VLOG(1) << "checkpoint is " << checkpoint_path.value()
             << "\nserver is " << kCrashReportURL
             << "\nmaximum " << sender_->max_reports_per_day() << " reports/day"
             << "\nreporter is " << reporter_tag_;
   }
   // Start servicing clients.
   if (!dumper_->Start()) {
     LOG(ERROR) << "could not start dumper";
@@ skipping 213 matching lines @@
                                                              SDDL_REVISION,
                                                              &sec_desc, NULL)) {
     if (::GetSecurityDescriptorSacl(sec_desc, &sacl_present, &sacl,
                                     &sacl_defaulted)) {
       return sec_desc;
     }
   }
 
   return NULL;
 }
+
+}  // namespace breakpad