RefCounted types should not have public destructors, chromeos edition

chrome/browser/chromeos/login/signed_settings.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/browser/chromeos/login/signed_settings.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 40 matching lines @@
 SignedSettings::ReturnCode SignedSettings::MapKeyOpCode(
     OwnerManager::KeyOpCode return_code) {
   return (return_code == OwnerManager::KEY_UNAVAILABLE ?
           KEY_UNAVAILABLE : BAD_SIGNATURE);
 }
 
 class StorePolicyOp : public SignedSettings {
  public:
   StorePolicyOp(em::PolicyFetchResponse* policy,
                 SignedSettings::Delegate<bool>* d);
-  virtual ~StorePolicyOp();
-  void Execute();
-  void Fail(SignedSettings::ReturnCode code);
   void Succeed(bool value);
   // Implementation of OwnerManager::Delegate
-  void OnKeyOpComplete(const OwnerManager::KeyOpCode return_code,
-                       const std::vector<uint8>& payload);
+  virtual void Execute() OVERRIDE;
+  virtual void Fail(SignedSettings::ReturnCode code) OVERRIDE;
+  virtual void OnKeyOpComplete(const OwnerManager::KeyOpCode return_code,
+                               const std::vector<uint8>& payload) OVERRIDE;
+
+ protected:
+  virtual ~StorePolicyOp();
 
  private:
+  void RequestStorePolicy();
+
   void OnBoolComplete(bool success);
   // Always call d_->OnSettingOpCompleted() via this call.
   // It guarantees that the callback will not be triggered until _after_
   // Execute() returns, which is implicitly assumed by SignedSettingsHelper
   // in some cases.
   void PerformCallback(SignedSettings::ReturnCode code, bool value);
 
   em::PolicyFetchResponse* policy_;
   SignedSettings::Delegate<bool>* d_;
-
-  void RequestStorePolicy();
 };
 
 class RetrievePolicyOp : public SignedSettings {
  public:
   explicit RetrievePolicyOp(
       SignedSettings::Delegate<const em::PolicyFetchResponse&>* d);
-  virtual ~RetrievePolicyOp();
-  void Execute();
-  void Fail(SignedSettings::ReturnCode code);
   void Succeed(const em::PolicyFetchResponse& value);
   // Implementation of OwnerManager::Delegate
-  void OnKeyOpComplete(const OwnerManager::KeyOpCode return_code,
-                       const std::vector<uint8>& payload);
+  virtual void Execute() OVERRIDE;
+  virtual void Fail(SignedSettings::ReturnCode code) OVERRIDE;
+  virtual void OnKeyOpComplete(const OwnerManager::KeyOpCode return_code,
+                               const std::vector<uint8>& payload) OVERRIDE;
+
+ protected:
+  virtual ~RetrievePolicyOp();
 
  private:
   void OnStringComplete(const std::string& serialized_proto);
   // Always call d_->OnSettingOpCompleted() via this call.
   // It guarantees that the callback will not be triggered until _after_
   // Execute() returns, which is implicitly assumed by SignedSettingsHelper
   // in some cases.
   void PerformCallback(SignedSettings::ReturnCode code,
                        const em::PolicyFetchResponse& value);
 
@@ skipping 19 matching lines @@
   return new RetrievePolicyOp(d);
 }
 
 
 StorePolicyOp::StorePolicyOp(em::PolicyFetchResponse* policy,
                              SignedSettings::Delegate<bool>* d)
     : policy_(policy),
       d_(d) {
 }
 
-StorePolicyOp::~StorePolicyOp() {}
-
-void StorePolicyOp::OnBoolComplete(bool success) {
-  if (success)
-    Succeed(true);
-  else
-    Fail(NOT_FOUND);
+void StorePolicyOp::Succeed(bool ignored) {
+  SignedSettings::ReturnCode code = SUCCESS;
+  bool to_ret = true;
+  em::PolicyData poldata;
+  if (SignedSettings::PolicyIsSane(*policy_, &poldata)) {
+  } else {
+    code = NOT_FOUND;
+    to_ret = false;
+  }
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(&StorePolicyOp::PerformCallback, this, code, to_ret));
 }
 
 void StorePolicyOp::Execute() {
   // get protobuf contents to sign
   if (!policy_->has_policy_data())
     Fail(OPERATION_FAILED);
   else if (!policy_->has_policy_data_signature())
     service_->StartSigningAttempt(policy_->policy_data(), this);
   else
     RequestStorePolicy();
 }
 
 void StorePolicyOp::Fail(SignedSettings::ReturnCode code) {
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&StorePolicyOp::PerformCallback, this, code, false));
 }
 
-void StorePolicyOp::Succeed(bool ignored) {
-  SignedSettings::ReturnCode code = SUCCESS;
-  bool to_ret = true;
-  em::PolicyData poldata;
-  if (SignedSettings::PolicyIsSane(*policy_, &poldata)) {
-  } else {
-    code = NOT_FOUND;
-    to_ret = false;
-  }
-  BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      base::Bind(&StorePolicyOp::PerformCallback, this, code, to_ret));
-}
-
 void StorePolicyOp::OnKeyOpComplete(const OwnerManager::KeyOpCode return_code,
                                     const std::vector<uint8>& payload) {
   // Ensure we're on the UI thread, due to the need to send DBus traffic.
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&StorePolicyOp::OnKeyOpComplete, this, return_code,
                    payload));
     return;
   }
   VLOG(2) << "StorePolicyOp::OnKeyOpComplete return_code = " << return_code;
   // Now, sure we're on the UI thread.
   if (return_code == OwnerManager::SUCCESS) {
     policy_->set_policy_data_signature(std::string(payload.begin(),
                                                    payload.end()));
     RequestStorePolicy();
     return;
   }
   Fail(SignedSettings::MapKeyOpCode(return_code));
 }
 
+StorePolicyOp::~StorePolicyOp() {}
+
 void StorePolicyOp::RequestStorePolicy() {
   std::string serialized;
   if (policy_->SerializeToString(&serialized)) {
     DBusThreadManager::Get()->GetSessionManagerClient()->StoreDevicePolicy(
         serialized,
         base::Bind(&StorePolicyOp::OnBoolComplete, this));
   } else {
     Fail(OPERATION_FAILED);
   }
 }
 
+void StorePolicyOp::OnBoolComplete(bool success) {
+  if (success)
+    Succeed(true);
+  else
+    Fail(NOT_FOUND);
+}
+
 void StorePolicyOp::PerformCallback(SignedSettings::ReturnCode code,
                                     bool value) {
   d_->OnSettingsOpCompleted(code, value);
 }
 
 RetrievePolicyOp::RetrievePolicyOp(
     SignedSettings::Delegate<const em::PolicyFetchResponse&>* d)
     : d_(d) {
 }
 
-RetrievePolicyOp::~RetrievePolicyOp() {}
+void RetrievePolicyOp::Succeed(const em::PolicyFetchResponse& value) {
+  em::PolicyData poldata;
+  if (SignedSettings::PolicyIsSane(value, &poldata)) {
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        base::Bind(&RetrievePolicyOp::PerformCallback, this, SUCCESS, value));
+  } else {
+    Fail(NOT_FOUND);
+  }
+}
 
 void RetrievePolicyOp::Execute() {
   DBusThreadManager::Get()->GetSessionManagerClient()->RetrieveDevicePolicy(
       base::Bind(&RetrievePolicyOp::OnStringComplete, this));
 }
 
 void RetrievePolicyOp::Fail(SignedSettings::ReturnCode code) {
   VLOG(2) << "RetrievePolicyOp::Execute() failed with " << code;
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&RetrievePolicyOp::PerformCallback, this, code,
                  em::PolicyFetchResponse()));
 }
 
-void RetrievePolicyOp::Succeed(const em::PolicyFetchResponse& value) {
-  em::PolicyData poldata;
-  if (SignedSettings::PolicyIsSane(value, &poldata)) {
-    BrowserThread::PostTask(
-        BrowserThread::UI, FROM_HERE,
-        base::Bind(&RetrievePolicyOp::PerformCallback, this, SUCCESS, value));
-  } else {
-    Fail(NOT_FOUND);
-  }
-}
-
 void RetrievePolicyOp::OnKeyOpComplete(
     const OwnerManager::KeyOpCode return_code,
     const std::vector<uint8>& payload) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&RetrievePolicyOp::OnKeyOpComplete, this, return_code,
                    payload));
     return;
   }
   // Now, sure we're on the UI thread.
   if (return_code == OwnerManager::SUCCESS)
     Succeed(policy_);
   else
     Fail(SignedSettings::MapKeyOpCode(return_code));
 }
 
+RetrievePolicyOp::~RetrievePolicyOp() {}
+
 void RetrievePolicyOp::OnStringComplete(const std::string& serialized_proto) {
   ProcessPolicy(serialized_proto);
 }
 
 void RetrievePolicyOp::ProcessPolicy(const std::string& serialized_proto) {
   if (serialized_proto.empty() || !policy_.ParseFromString(serialized_proto) ||
       (!policy_.has_policy_data() && !policy_.has_policy_data_signature())) {
     Fail(NOT_FOUND);
     return;
   }
@@ skipping 10 matching lines @@
   sig.assign(sig_ptr, sig_ptr + policy_.policy_data_signature().length());
   service_->StartVerifyAttempt(policy_.policy_data(), sig, this);
 }
 
 void RetrievePolicyOp::PerformCallback(SignedSettings::ReturnCode code,
                                        const em::PolicyFetchResponse& value) {
   d_->OnSettingsOpCompleted(code, value);
 }
 
 }  // namespace chromeos