Home | History | Annotate | Download | only in local_discovery
      1 // Copyright 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #ifndef CHROME_BROWSER_LOCAL_DISCOVERY_PRIVET_HTTP_IMPL_H_
      6 #define CHROME_BROWSER_LOCAL_DISCOVERY_PRIVET_HTTP_IMPL_H_
      7 
      8 #include <string>
      9 
     10 #include "base/callback.h"
     11 #include "base/file_util.h"
     12 #include "base/memory/ref_counted.h"
     13 #include "base/memory/weak_ptr.h"
     14 #include "chrome/browser/local_discovery/privet_http.h"
     15 #include "components/cloud_devices/common/cloud_device_description.h"
     16 #include "printing/pdf_render_settings.h"
     17 
     18 namespace printing {
     19 struct PwgRasterSettings;
     20 };
     21 
     22 namespace local_discovery {
     23 
     24 class PrivetHTTPClient;
     25 
     26 class PrivetInfoOperationImpl : public PrivetJSONOperation,
     27                                 public PrivetURLFetcher::Delegate {
     28  public:
     29   PrivetInfoOperationImpl(PrivetHTTPClient* privet_client,
     30                           const PrivetJSONOperation::ResultCallback& callback);
     31   virtual ~PrivetInfoOperationImpl();
     32 
     33   virtual void Start() OVERRIDE;
     34 
     35   virtual PrivetHTTPClient* GetHTTPClient() OVERRIDE;
     36 
     37   virtual void OnError(PrivetURLFetcher* fetcher,
     38                        PrivetURLFetcher::ErrorType error) OVERRIDE;
     39   virtual void OnParsedJson(PrivetURLFetcher* fetcher,
     40                             const base::DictionaryValue* value,
     41                             bool has_error) OVERRIDE;
     42 
     43  private:
     44   PrivetHTTPClient* privet_client_;
     45   PrivetJSONOperation::ResultCallback callback_;
     46   scoped_ptr<PrivetURLFetcher> url_fetcher_;
     47 };
     48 
     49 class PrivetRegisterOperationImpl
     50     : public PrivetRegisterOperation,
     51       public PrivetURLFetcher::Delegate,
     52       public base::SupportsWeakPtr<PrivetRegisterOperationImpl> {
     53  public:
     54   PrivetRegisterOperationImpl(PrivetHTTPClient* privet_client,
     55                               const std::string& user,
     56                               PrivetRegisterOperation::Delegate* delegate);
     57   virtual ~PrivetRegisterOperationImpl();
     58 
     59   virtual void Start() OVERRIDE;
     60   virtual void Cancel() OVERRIDE;
     61   virtual void CompleteRegistration() OVERRIDE;
     62 
     63   virtual void OnError(PrivetURLFetcher* fetcher,
     64                        PrivetURLFetcher::ErrorType error) OVERRIDE;
     65 
     66   virtual void OnParsedJson(PrivetURLFetcher* fetcher,
     67                             const base::DictionaryValue* value,
     68                             bool has_error) OVERRIDE;
     69 
     70   virtual void OnNeedPrivetToken(
     71       PrivetURLFetcher* fetcher,
     72       const PrivetURLFetcher::TokenCallback& callback) OVERRIDE;
     73 
     74   virtual PrivetHTTPClient* GetHTTPClient() OVERRIDE;
     75  private:
     76   class Cancelation : public PrivetURLFetcher::Delegate {
     77    public:
     78     Cancelation(PrivetHTTPClient* privet_client, const std::string& user);
     79     virtual ~Cancelation();
     80 
     81     virtual void OnError(PrivetURLFetcher* fetcher,
     82                          PrivetURLFetcher::ErrorType error) OVERRIDE;
     83 
     84     virtual void OnParsedJson(PrivetURLFetcher* fetcher,
     85                               const base::DictionaryValue* value,
     86                               bool has_error) OVERRIDE;
     87 
     88     void Cleanup();
     89 
     90    private:
     91     scoped_ptr<PrivetURLFetcher> url_fetcher_;
     92   };
     93 
     94   // Arguments is JSON value from request.
     95   typedef base::Callback<void(const base::DictionaryValue&)>
     96       ResponseHandler;
     97 
     98   void StartInfoOperation();
     99   void OnPrivetInfoDone(const base::DictionaryValue* value);
    100 
    101   void StartResponse(const base::DictionaryValue& value);
    102   void GetClaimTokenResponse(const base::DictionaryValue& value);
    103   void CompleteResponse(const base::DictionaryValue& value);
    104 
    105   void SendRequest(const std::string& action);
    106 
    107   std::string user_;
    108   std::string current_action_;
    109   scoped_ptr<PrivetURLFetcher> url_fetcher_;
    110   PrivetRegisterOperation::Delegate* delegate_;
    111   PrivetHTTPClient* privet_client_;
    112   ResponseHandler next_response_handler_;
    113   // Required to ensure destroying completed register operations doesn't cause
    114   // extraneous cancelations.
    115   bool ongoing_;
    116 
    117   scoped_ptr<PrivetJSONOperation> info_operation_;
    118   std::string expected_id_;
    119 };
    120 
    121 class PrivetJSONOperationImpl : public PrivetJSONOperation,
    122                                 public PrivetURLFetcher::Delegate {
    123  public:
    124   PrivetJSONOperationImpl(PrivetHTTPClient* privet_client,
    125                           const std::string& path,
    126                           const std::string& query_params,
    127                           const PrivetJSONOperation::ResultCallback& callback);
    128   virtual ~PrivetJSONOperationImpl();
    129   virtual void Start() OVERRIDE;
    130 
    131   virtual PrivetHTTPClient* GetHTTPClient() OVERRIDE;
    132 
    133   virtual void OnError(PrivetURLFetcher* fetcher,
    134                        PrivetURLFetcher::ErrorType error) OVERRIDE;
    135   virtual void OnParsedJson(PrivetURLFetcher* fetcher,
    136                             const base::DictionaryValue* value,
    137                             bool has_error) OVERRIDE;
    138   virtual void OnNeedPrivetToken(
    139       PrivetURLFetcher* fetcher,
    140       const PrivetURLFetcher::TokenCallback& callback) OVERRIDE;
    141 
    142  private:
    143   PrivetHTTPClient* privet_client_;
    144   std::string path_;
    145   std::string query_params_;
    146   PrivetJSONOperation::ResultCallback callback_;
    147 
    148   scoped_ptr<PrivetURLFetcher> url_fetcher_;
    149 };
    150 
    151 class PrivetDataReadOperationImpl : public PrivetDataReadOperation,
    152                                     public PrivetURLFetcher::Delegate {
    153  public:
    154   PrivetDataReadOperationImpl(
    155       PrivetHTTPClient* privet_client,
    156       const std::string& path,
    157       const std::string& query_params,
    158       const PrivetDataReadOperation::ResultCallback& callback);
    159   virtual ~PrivetDataReadOperationImpl();
    160 
    161   virtual void Start() OVERRIDE;
    162 
    163   virtual void SetDataRange(int range_start, int range_end) OVERRIDE;
    164 
    165   virtual void SaveDataToFile() OVERRIDE;
    166 
    167   virtual PrivetHTTPClient* GetHTTPClient() OVERRIDE;
    168 
    169   virtual void OnError(PrivetURLFetcher* fetcher,
    170                        PrivetURLFetcher::ErrorType error) OVERRIDE;
    171   virtual void OnParsedJson(PrivetURLFetcher* fetcher,
    172                             const base::DictionaryValue* value,
    173                             bool has_error) OVERRIDE;
    174   virtual void OnNeedPrivetToken(
    175       PrivetURLFetcher* fetcher,
    176       const PrivetURLFetcher::TokenCallback& callback) OVERRIDE;
    177   virtual bool OnRawData(PrivetURLFetcher* fetcher,
    178                          bool is_file,
    179                          const std::string& data_str,
    180                          const base::FilePath& file_path) OVERRIDE;
    181 
    182  private:
    183   PrivetHTTPClient* privet_client_;
    184   std::string path_;
    185   std::string query_params_;
    186   int range_start_;
    187   int range_end_;
    188   PrivetDataReadOperation::ResultCallback callback_;
    189 
    190   bool has_range_;
    191   bool save_to_file_;
    192 
    193   scoped_ptr<PrivetURLFetcher> url_fetcher_;
    194 };
    195 
    196 class PrivetLocalPrintOperationImpl
    197     : public PrivetLocalPrintOperation,
    198       public PrivetURLFetcher::Delegate {
    199  public:
    200   PrivetLocalPrintOperationImpl(PrivetHTTPClient* privet_client,
    201                                 PrivetLocalPrintOperation::Delegate* delegate);
    202 
    203   virtual ~PrivetLocalPrintOperationImpl();
    204   virtual void Start() OVERRIDE;
    205 
    206   virtual void SetData(base::RefCountedBytes* data) OVERRIDE;
    207 
    208   virtual void SetCapabilities(const std::string& capabilities) OVERRIDE;
    209 
    210   virtual void SetTicket(const std::string& ticket) OVERRIDE;
    211 
    212   virtual void SetUsername(const std::string& user) OVERRIDE;
    213 
    214   virtual void SetJobname(const std::string& jobname) OVERRIDE;
    215 
    216   virtual void SetOffline(bool offline) OVERRIDE;
    217 
    218   virtual void SetPageSize(const gfx::Size& page_size) OVERRIDE;
    219 
    220   virtual void SetPWGRasterConverterForTesting(
    221       scoped_ptr<PWGRasterConverter> pwg_raster_converter) OVERRIDE;
    222 
    223   virtual PrivetHTTPClient* GetHTTPClient() OVERRIDE;
    224 
    225   virtual void OnError(PrivetURLFetcher* fetcher,
    226                        PrivetURLFetcher::ErrorType error) OVERRIDE;
    227   virtual void OnParsedJson(PrivetURLFetcher* fetcher,
    228                             const base::DictionaryValue* value,
    229                             bool has_error) OVERRIDE;
    230   virtual void OnNeedPrivetToken(
    231       PrivetURLFetcher* fetcher,
    232       const PrivetURLFetcher::TokenCallback& callback) OVERRIDE;
    233 
    234  private:
    235   typedef base::Callback<void(bool, const base::DictionaryValue* value)>
    236       ResponseCallback;
    237 
    238   void StartInitialRequest();
    239   void DoCreatejob();
    240   void DoSubmitdoc();
    241 
    242   void StartConvertToPWG();
    243   void StartPrinting();
    244 
    245   void OnPrivetInfoDone(const base::DictionaryValue* value);
    246   void OnSubmitdocResponse(bool has_error,
    247                            const base::DictionaryValue* value);
    248   void OnCreatejobResponse(bool has_error,
    249                            const base::DictionaryValue* value);
    250   void OnPWGRasterConverted(bool success, const base::FilePath& pwg_file_path);
    251   void FillPwgRasterSettings(printing::PwgRasterSettings* transfrom_settings);
    252 
    253   PrivetHTTPClient* privet_client_;
    254   PrivetLocalPrintOperation::Delegate* delegate_;
    255 
    256   ResponseCallback current_response_;
    257 
    258   cloud_devices::CloudDeviceDescription ticket_;
    259   cloud_devices::CloudDeviceDescription capabilities_;
    260 
    261   scoped_refptr<base::RefCountedBytes> data_;
    262   base::FilePath pwg_file_path_;
    263 
    264   bool use_pdf_;
    265   bool has_extended_workflow_;
    266   bool started_;
    267   bool offline_;
    268   gfx::Size page_size_;
    269   int dpi_;
    270 
    271   std::string user_;
    272   std::string jobname_;
    273 
    274   std::string jobid_;
    275 
    276   int invalid_job_retries_;
    277 
    278   scoped_ptr<PrivetURLFetcher> url_fetcher_;
    279   scoped_ptr<PrivetJSONOperation> info_operation_;
    280   scoped_ptr<PWGRasterConverter> pwg_raster_converter_;
    281 
    282   base::WeakPtrFactory<PrivetLocalPrintOperationImpl> weak_factory_;
    283 };
    284 
    285 class PrivetHTTPClientImpl : public PrivetHTTPClient {
    286  public:
    287   PrivetHTTPClientImpl(
    288       const std::string& name,
    289       const net::HostPortPair& host_port,
    290       net::URLRequestContextGetter* request_context);
    291   virtual ~PrivetHTTPClientImpl();
    292 
    293   // PrivetHTTPClient implementation.
    294   virtual const std::string& GetName() OVERRIDE;
    295   virtual scoped_ptr<PrivetJSONOperation> CreateInfoOperation(
    296       const PrivetJSONOperation::ResultCallback& callback) OVERRIDE;
    297   virtual scoped_ptr<PrivetURLFetcher> CreateURLFetcher(
    298       const GURL& url,
    299       net::URLFetcher::RequestType request_type,
    300       PrivetURLFetcher::Delegate* delegate) OVERRIDE;
    301   virtual void RefreshPrivetToken(
    302       const PrivetURLFetcher::TokenCallback& token_callback) OVERRIDE;
    303 
    304  private:
    305   typedef std::vector<PrivetURLFetcher::TokenCallback> TokenCallbackVector;
    306 
    307   void OnPrivetInfoDone(const base::DictionaryValue* value);
    308 
    309   std::string name_;
    310   scoped_refptr<net::URLRequestContextGetter> request_context_;
    311   net::HostPortPair host_port_;
    312 
    313   scoped_ptr<PrivetJSONOperation> info_operation_;
    314   TokenCallbackVector token_callbacks_;
    315 
    316   DISALLOW_COPY_AND_ASSIGN(PrivetHTTPClientImpl);
    317 };
    318 
    319 class PrivetV1HTTPClientImpl : public PrivetV1HTTPClient {
    320  public:
    321   explicit PrivetV1HTTPClientImpl(scoped_ptr<PrivetHTTPClient> info_client);
    322   virtual ~PrivetV1HTTPClientImpl();
    323 
    324   virtual const std::string& GetName() OVERRIDE;
    325   virtual scoped_ptr<PrivetJSONOperation> CreateInfoOperation(
    326       const PrivetJSONOperation::ResultCallback& callback) OVERRIDE;
    327   virtual scoped_ptr<PrivetRegisterOperation> CreateRegisterOperation(
    328       const std::string& user,
    329       PrivetRegisterOperation::Delegate* delegate) OVERRIDE;
    330   virtual scoped_ptr<PrivetJSONOperation> CreateCapabilitiesOperation(
    331       const PrivetJSONOperation::ResultCallback& callback) OVERRIDE;
    332   virtual scoped_ptr<PrivetLocalPrintOperation> CreateLocalPrintOperation(
    333       PrivetLocalPrintOperation::Delegate* delegate) OVERRIDE;
    334   virtual scoped_ptr<PrivetJSONOperation> CreateStorageListOperation(
    335       const std::string& path,
    336       const PrivetJSONOperation::ResultCallback& callback) OVERRIDE;
    337   virtual scoped_ptr<PrivetDataReadOperation> CreateStorageReadOperation(
    338       const std::string& path,
    339       const PrivetDataReadOperation::ResultCallback& callback) OVERRIDE;
    340 
    341  private:
    342   PrivetHTTPClient* info_client() { return info_client_.get(); }
    343 
    344   scoped_ptr<PrivetHTTPClient> info_client_;
    345 
    346   DISALLOW_COPY_AND_ASSIGN(PrivetV1HTTPClientImpl);
    347 };
    348 
    349 class PrivetV3HTTPClientImpl : public PrivetV3HTTPClient {
    350  public:
    351   explicit PrivetV3HTTPClientImpl(scoped_ptr<PrivetHTTPClient> info_client);
    352   virtual ~PrivetV3HTTPClientImpl();
    353 
    354   virtual const std::string& GetName() OVERRIDE;
    355   virtual scoped_ptr<PrivetJSONOperation> CreateInfoOperation(
    356       const PrivetJSONOperation::ResultCallback& callback) OVERRIDE;
    357 
    358  private:
    359   PrivetHTTPClient* info_client() { return info_client_.get(); }
    360 
    361   scoped_ptr<PrivetHTTPClient> info_client_;
    362 
    363   DISALLOW_COPY_AND_ASSIGN(PrivetV3HTTPClientImpl);
    364 };
    365 
    366 }  // namespace local_discovery
    367 #endif  // CHROME_BROWSER_LOCAL_DISCOVERY_PRIVET_HTTP_IMPL_H_
    368