Wrap Sparkle's minimum interface with C++.

atom.gyp

@@ -53,6 +53,11 @@
       'browser/api/atom_api_window.h',
       'browser/api/atom_browser_bindings.cc',
       'browser/api/atom_browser_bindings.h',
+      'browser/auto_updater.cc',
+      'browser/auto_updater.h',
+      'browser/auto_updater_delegate.cc',
+      'browser/auto_updater_delegate.h',
+      'browser/auto_updater_mac.mm',
       'browser/atom_application_mac.h',
       'browser/atom_application_mac.mm',
       'browser/atom_application_delegate_mac.h',

browser/auto_updater.cc

@@ -0,0 +1,19 @@
+// Copyright (c) 2013 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "browser/auto_updater.h"
+
+namespace auto_updater {
+
+AutoUpdaterDelegate* AutoUpdater::delegate_ = NULL;
+
+AutoUpdaterDelegate* AutoUpdater::GetDelegate() {
+  return delegate_;
+}
+
+void AutoUpdater::SetDelegate(AutoUpdaterDelegate* delegate) {
+  delegate_ = delegate;
+}
+
+}  // namespace auto_updater

browser/auto_updater.h

@@ -0,0 +1,34 @@
+// Copyright (c) 2013 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_AUTO_UPDATER_H_
+#define ATOM_BROWSER_AUTO_UPDATER_H_
+
+#include "base/basictypes.h"
+
+namespace auto_updater {
+
+class AutoUpdaterDelegate;
+
+class AutoUpdater {
+ public:
+  // Gets/Sets the delegate.
+  static AutoUpdaterDelegate* GetDelegate();
+  static void SetDelegate(AutoUpdaterDelegate* delegate);
+
+  static void Init();
+
+  static void SetAutomaticallyChecksForUpdates(bool yes);
+  static void SetAutomaticallyDownloadsUpdates(bool yes);
+  static void CheckForUpdatesInBackground();
+
+ private:
+  static AutoUpdaterDelegate* delegate_;
+
+  DISALLOW_IMPLICIT_CONSTRUCTORS(AutoUpdater);
+};
+
+}  // namespace auto_updater
+
+#endif  // ATOM_BROWSER_AUTO_UPDATER_H_

browser/auto_updater_delegate.cc

@@ -0,0 +1,16 @@
+// Copyright (c) 2013 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "browser/auto_updater_delegate.h"
+
+#include "base/callback.h"
+
+namespace auto_updater {
+
+void AutoUpdaterDelegate::WillInstallUpdate(const std::string& version,
+                                            const base::Closure& install) {
+  install.Run();
+}
+
+}  // namespace auto_updater

browser/auto_updater_delegate.h

@@ -0,0 +1,25 @@
+// Copyright (c) 2013 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_AUTO_UPDATER_DELEGATE_H_
+#define ATOM_BROWSER_AUTO_UPDATER_DELEGATE_H_
+
+#include <string>
+
+#include "base/callback_forward.h"
+
+namespace auto_updater {
+
+class AutoUpdaterDelegate {
+ public:
+  virtual void WillInstallUpdate(const std::string& version,
+                                 const base::Closure& install);
+
+ protected:
+  virtual ~AutoUpdaterDelegate() {}
+};
+
+}  // namespace auto_updater
+
+#endif  // ATOM_BROWSER_AUTO_UPDATER_DELEGATE_H_

browser/auto_updater_mac.mm

@@ -0,0 +1,89 @@
+// Copyright (c) 2013 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "browser/auto_updater.h"
+
+// Sparkle's headers are throwing compilation warnings, supress them.
+#pragma GCC diagnostic ignored "-Wmissing-method-return-type"
+#import <Sparkle/Sparkle.h>
+
+#include "base/bind.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/strings/sys_string_conversions.h"
+#include "browser/auto_updater_delegate.h"
+
+using auto_updater::AutoUpdaterDelegate;
+
+namespace {
+
+struct NSInvocationDeleter {
+  inline void operator()(NSInvocation* invocation) const {
+    [invocation release];
+  }
+};
+
+typedef scoped_ptr<NSInvocation, NSInvocationDeleter> ScopedNSInvocation;
+
+// We are passing the NSInvocation as scoped_ptr, because we want to make sure
+// whether or not the callback is called, the NSInvocation should alwasy be
+// released, the only way to ensure it is to use scoped_ptr.
+void CallNSInvocation(ScopedNSInvocation invocation) {
+  [invocation.get() invoke];
+}
+
+}  // namespace
+
+@interface SUUpdaterDelegate : NSObject {
+}
+@end
+
+@implementation SUUpdaterDelegate
+
+- (void)updater:(SUUpdater*)updater
+        willInstallUpdateOnQuit:(SUAppcastItem*)update
+        immediateInstallationInvocation:(NSInvocation*)invocation {
+  AutoUpdaterDelegate* delegate = auto_updater::AutoUpdater::GetDelegate();
+  if (!delegate) {
+    [invocation invoke];
+    return;
+  }
+
+  std::string version(base::SysNSStringToUTF8([update versionString]));
+  ScopedNSInvocation invocation_ptr([invocation retain]);
+  delegate->WillInstallUpdate(
+      version,
+      base::Bind(&CallNSInvocation, base::Passed(invocation_ptr.Pass())));
+}
+
+- (void)updaterWillRelaunchApplication:(SUUpdater*)updater {
+  [[SUUpdater sharedUpdater] setDelegate:nil];
+}
+
+@end
+
+namespace auto_updater {
+
+// static
+void AutoUpdater::Init() {
+  SUUpdaterDelegate* delegate = [[SUUpdaterDelegate alloc] init];
+  [delegate autorelease];
+  [[SUUpdater sharedUpdater] setDelegate:delegate];
+}
+
+// static
+void AutoUpdater::SetAutomaticallyChecksForUpdates(bool yes) {
+  [[SUUpdater sharedUpdater] setAutomaticallyChecksForUpdates:yes];
+}
+
+// static
+void AutoUpdater::SetAutomaticallyDownloadsUpdates(bool yes) {
+  [[SUUpdater sharedUpdater] setAutomaticallyDownloadsUpdates:yes];
+}
+
+// static
+void AutoUpdater::CheckForUpdatesInBackground() {
+  [[SUUpdater sharedUpdater] checkForUpdatesInBackground];
+}
+
+}  // namespace auto_updater