Chrome proxy refactoring.

chrome/service/cloud_print/printer_job_handler.h

 // Copyright (c) 2011 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 CHROME_SERVICE_CLOUD_PRINT_PRINTER_JOB_HANDLER_H_
 #define CHROME_SERVICE_CLOUD_PRINT_PRINTER_JOB_HANDLER_H_
 #pragma once
 
 #include <list>
 #include <string>
@@ skipping 15 matching lines @@
 // imlements a state machine that transitions from Start to various states. The
 // various states are shown in the below diagram.
 // the status on the server.
 
 //                            Start --> No pending tasks --> Done
 //                              |
 //                              |
 //                              | Have Pending tasks
 //                              |
 //                              |
-//       <----Delete Pending -- | ---Update Pending----->
-//       |                      |                       |
-//       |                      |                       |
-//       |                      |                       |
-// Delete Printer from server   |                 Update Printer info on server
-//   Shutdown                   |                      Go to Stop
+//                              | ---Update Pending----->
+//                              |                       |
+//                              |                       |
+//                              |                       |
+//                              |                 Update Printer info on server
+//                              |                      Go to Stop
 //                              |
 //                              | Job Available
 //                              |
 //                              |
 //                        Fetch Next Job Metadata
 //                        Fetch Print Ticket
 //                        Fetch Print Data
 //                        Spool Print Job
 //                        Create Job StatusUpdater for job
 //                        Mark job as "in progress" on server
@@ skipping 29 matching lines @@
     std::string job_title_;
     std::string print_ticket_;
     FilePath print_data_file_path_;
     std::string print_data_mime_type_;
     std::vector<std::string> tags_;
   };
 
  public:
   class Delegate {
    public:
-     virtual void OnPrinterJobHandlerShutdown(
-        PrinterJobHandler* job_handler, const std::string& printer_id) = 0;
+     // Notify delegate about authentication error.
      virtual void OnAuthError() = 0;
-     // Called when the PrinterJobHandler cannot find the printer locally. The
-     // delegate returns |delete_from_server| to true if the printer should be
-     // deleted from the server,false otherwise.
-     virtual void OnPrinterNotFound(const std::string& printer_name,
-                                    bool* delete_from_server) = 0;
+     // Notify delegate that printer has been deleted.
+     virtual void OnPrinterDeleted(const std::string& printer_name) = 0;
 
    protected:
      virtual ~Delegate() {}
   };
 
   struct PrinterInfoFromCloud {
     std::string printer_id;
     std::string caps_hash;
     std::string tags_hash;
   };
 
   // Begin public interface
   PrinterJobHandler(const printing::PrinterBasicInfo& printer_info,
                     const PrinterInfoFromCloud& printer_info_from_server,
                     const GURL& cloud_print_server_url,
                     cloud_print::PrintSystem* print_system,
                     Delegate* delegate);
   virtual ~PrinterJobHandler();
   bool Initialize();
+  std::string GetPrinterName() const;
   // Requests a job check. |reason| is the reason for fetching the job. Used
   // for logging and diagnostc purposes.
   void CheckForJobs(const std::string& reason);
   // Shutdown everything (the process is exiting).
   void Shutdown();
   base::TimeTicks last_job_fetch_time() const { return last_job_fetch_time_; }
   // End public interface
 
   // Begin Delegate implementations
 
   // CloudPrintURLFetcher::Delegate implementation.
   virtual CloudPrintURLFetcher::ResponseAction HandleRawResponse(
       const content::URLFetcher* source,
       const GURL& url,
       const net::URLRequestStatus& status,
       int response_code,
       const net::ResponseCookies& cookies,
       const std::string& data);
   virtual CloudPrintURLFetcher::ResponseAction HandleRawData(
       const content::URLFetcher* source,
       const GURL& url,
       const std::string& data);
   virtual CloudPrintURLFetcher::ResponseAction HandleJSONData(
       const content::URLFetcher* source,
       const GURL& url,
       base::DictionaryValue* json_data,
       bool succeeded);
   virtual void OnRequestGiveUp();
-  virtual void OnRequestAuthError();
+  virtual CloudPrintURLFetcher::ResponseAction OnRequestAuthError();
+  virtual std::string GetAuthHeader();
 
   // JobStatusUpdater::Delegate implementation
   virtual bool OnJobCompleted(JobStatusUpdater* updater);
   virtual void OnAuthError();
 
   // cloud_print::PrinterWatcherDelegate implementation
   virtual void OnPrinterDeleted();
   virtual void OnPrinterChanged();
   virtual void OnJobChanged();
 
@@ skipping 16 matching lines @@
       (PrinterJobHandler::*DataHandler)(const content::URLFetcher* source,
                                         const GURL& url,
                                         const std::string& data);
   // Begin request handlers for each state in the state machine
   CloudPrintURLFetcher::ResponseAction HandlePrinterUpdateResponse(
       const content::URLFetcher* source,
       const GURL& url,
       base::DictionaryValue* json_data,
       bool succeeded);
 
-  CloudPrintURLFetcher::ResponseAction HandlePrinterDeleteResponse(
-      const content::URLFetcher* source,
-      const GURL& url,
-      base::DictionaryValue* json_data,
-      bool succeeded);
-
   CloudPrintURLFetcher::ResponseAction HandleJobMetadataResponse(
       const content::URLFetcher* source,
       const GURL& url,
       base::DictionaryValue* json_data,
       bool succeeded);
 
   CloudPrintURLFetcher::ResponseAction HandlePrintTicketResponse(
       const content::URLFetcher* source,
       const GURL& url,
       const std::string& data);
@@ skipping 82 matching lines @@
   // There may be pending tasks in the message queue when Shutdown is called.
   // We set this flag so as to do nothing in those tasks.
   bool shutting_down_;
 
   // A string indicating the reason we are fetching jobs from the server
   // (used to specify the reason in the fetch URL).
   std::string job_fetch_reason_;
   // Flags that specify various pending server updates
   bool job_check_pending_;
   bool printer_update_pending_;
-  bool printer_delete_pending_;
 
   // Some task in the state machine is in progress.
   bool task_in_progress_;
   scoped_refptr<cloud_print::PrintSystem::PrinterWatcher> printer_watcher_;
   typedef std::list< scoped_refptr<JobStatusUpdater> > JobStatusUpdaterList;
   JobStatusUpdaterList job_status_updater_list_;
 
   base::TimeTicks last_job_fetch_time_;
 
   DISALLOW_COPY_AND_ASSIGN(PrinterJobHandler);
 };
 
 // This typedef is to workaround the issue with certain versions of
 // Visual Studio where it gets confused between multiple Delegate
 // classes and gives a C2500 error. (I saw this error on the try bots -
 // the workaround was not needed for my machine).
 typedef PrinterJobHandler::Delegate PrinterJobHandlerDelegate;
 
 #endif  // CHROME_SERVICE_CLOUD_PRINT_PRINTER_JOB_HANDLER_H_