Move NetworkingPrivateDelegate::CryptoVerify to networking_cast_private

extensions/browser/api/networking_private/networking_private_delegate.h

 // Copyright 2014 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.
 
 #ifndef EXTENSIONS_BROWSER_API_NETWORKING_PRIVATE_NETWORKING_PRIVATE_DELEGATE_H_
 #define EXTENSIONS_BROWSER_API_NETWORKING_PRIVATE_NETWORKING_PRIVATE_DELEGATE_H_
 
 #include <memory>
 #include <string>
 #include <vector>
@@ skipping 16 matching lines @@
   using DictionaryCallback =
       base::Callback<void(std::unique_ptr<base::DictionaryValue>)>;
   using VoidCallback = base::Callback<void()>;
   using BoolCallback = base::Callback<void(bool)>;
   using StringCallback = base::Callback<void(const std::string&)>;
   using NetworkListCallback =
       base::Callback<void(std::unique_ptr<base::ListValue>)>;
   using FailureCallback = base::Callback<void(const std::string&)>;
   using DeviceStateList = std::vector<
       std::unique_ptr<api::networking_private::DeviceStateProperties>>;
-  using VerificationProperties =
-      api::networking_private::VerificationProperties;
-
-  // The Verify* methods will be forwarded to a delegate implementation if
-  // provided, otherwise they will fail. A separate delegate it used so that the
-  // current Verify* implementations are not exposed outside of src/chrome.
-  class VerifyDelegate {
-   public:
-    typedef NetworkingPrivateDelegate::VerificationProperties
-        VerificationProperties;
-    typedef NetworkingPrivateDelegate::BoolCallback BoolCallback;
-    typedef NetworkingPrivateDelegate::StringCallback StringCallback;
-    typedef NetworkingPrivateDelegate::FailureCallback FailureCallback;
-
-    VerifyDelegate();
-    virtual ~VerifyDelegate();
-
-    virtual void VerifyDestination(
-        const VerificationProperties& verification_properties,
-        const BoolCallback& success_callback,
-        const FailureCallback& failure_callback) = 0;
-    virtual void VerifyAndEncryptCredentials(
-        const std::string& guid,
-        const VerificationProperties& verification_properties,
-        const StringCallback& success_callback,
-        const FailureCallback& failure_callback) = 0;
-    virtual void VerifyAndEncryptData(
-        const VerificationProperties& verification_properties,
-        const std::string& data,
-        const StringCallback& success_callback,
-        const FailureCallback& failure_callback) = 0;
-
-   private:
-    DISALLOW_COPY_AND_ASSIGN(VerifyDelegate);
-  };
 
   // Delegate for forwarding UI requests, e.g. for showing the account UI.
   class UIDelegate {
    public:
     UIDelegate();
     virtual ~UIDelegate();
 
     // Navigate to the acoount details page for the cellular network associated
     // with |guid|.
     virtual void ShowAccountDetails(const std::string& guid) const = 0;
 
     // Possibly handle a connection failure, e.g. by showing the configuration
     // UI. Returns true if the error was handled, i.e. the UI was shown.
     virtual bool HandleConnectFailed(const std::string& guid,
                                      const std::string error) const = 0;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(UIDelegate);
   };
 
-  // If |verify_delegate| is not NULL, the Verify* methods will be forwarded
-  // to the delegate. Otherwise they will fail with a NotSupported error.
-  explicit NetworkingPrivateDelegate(
-      std::unique_ptr<VerifyDelegate> verify_delegate);
+  NetworkingPrivateDelegate();
   ~NetworkingPrivateDelegate() override;
 
   void set_ui_delegate(std::unique_ptr<UIDelegate> ui_delegate) {
     ui_delegate_ = std::move(ui_delegate);
   }
 
   const UIDelegate* ui_delegate() { return ui_delegate_.get(); }
 
   // Asynchronous methods
   virtual void GetProperties(const std::string& guid,
@@ skipping 80 matching lines @@
 
   // Returns true if a scan was requested. It may take many seconds for a scan
   // to complete. The scan may or may not trigger API events when complete.
   virtual bool RequestScan() = 0;
 
   // Optional methods for adding a NetworkingPrivateDelegateObserver for
   // implementations that require it (non-chromeos).
   virtual void AddObserver(NetworkingPrivateDelegateObserver* observer);
   virtual void RemoveObserver(NetworkingPrivateDelegateObserver* observer);
 
-  // Verify* methods are forwarded to |verify_delegate_| if not NULL.
-  void VerifyDestination(const VerificationProperties& verification_properties,
-                         const BoolCallback& success_callback,
-                         const FailureCallback& failure_callback);
-  void VerifyAndEncryptCredentials(
-      const std::string& guid,
-      const VerificationProperties& verification_properties,
-      const StringCallback& success_callback,
-      const FailureCallback& failure_callback);
-  void VerifyAndEncryptData(
-      const VerificationProperties& verification_properties,
-      const std::string& data,
-      const StringCallback& success_callback,
-      const FailureCallback& failure_callback);
-
  private:
-  // Interface for Verify* methods. May be null.
-  std::unique_ptr<VerifyDelegate> verify_delegate_;
-
   // Interface for UI methods. May be null.
   std::unique_ptr<UIDelegate> ui_delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateDelegate);
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_BROWSER_API_NETWORKING_PRIVATE_NETWORKING_PRIVATE_DELEGATE_H_