Hookup the PpdProvider in the printer setup flow.

chromeos/printing/ppd_provider.cc

 // Copyright 2016 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 "chromeos/printing/ppd_provider.h"
 
 #include <utility>
 
+#include "base/bind_helpers.h"
 #include "base/files/file_util.h"
 #include "base/json/json_parser.h"
 #include "base/memory/ptr_util.h"
 #include "base/sequence_checker.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/task_runner_util.h"
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "base/time/time.h"
@@ skipping 66 matching lines @@
         << "Can't have concurrent PpdProvider Resolve calls";
     resolve_inflight_ = true;
     auto cache_result = base::MakeUnique<base::Optional<base::FilePath>>();
     auto* raw_cache_result_ptr = cache_result.get();
     bool post_result = io_task_runner_->PostTaskAndReply(
         FROM_HERE, base::Bind(&PpdProviderImpl::ResolveDoCacheLookup,
                               weak_factory_.GetWeakPtr(), ppd_reference,
                               raw_cache_result_ptr),
         base::Bind(&PpdProviderImpl::ResolveCacheLookupDone,
                    weak_factory_.GetWeakPtr(), ppd_reference, cb,
-                   std::move(cache_result)));
+                   base::Passed(&cache_result)));
     DCHECK(post_result);
   }
 
   void QueryAvailable(const QueryAvailableCallback& cb) override {
     CHECK(!cb.is_null());
     CHECK(base::SequencedTaskRunnerHandle::IsSet())
         << "QueryAvailable() must be called from a SequencedTaskRunner context";
     auto cache_result = base::MakeUnique<
         base::Optional<const PpdProvider::AvailablePrintersMap*>>();
     CHECK(!query_inflight_)
         << "Can't have concurrent PpdProvider QueryAvailable calls";
     query_inflight_ = true;
     auto* raw_cache_result_ptr = cache_result.get();
     CHECK(io_task_runner_->PostTaskAndReply(
         FROM_HERE, base::Bind(&PpdProviderImpl::QueryAvailableDoCacheLookup,
                               weak_factory_.GetWeakPtr(), raw_cache_result_ptr),
         base::Bind(&PpdProviderImpl::QueryAvailableCacheLookupDone,
                    weak_factory_.GetWeakPtr(), cb, std::move(cache_result))));
   }
 
   bool CachePpd(const Printer::PpdReference& ppd_reference,
                 const base::FilePath& ppd_path) override {
+    VLOG(1) << "Caching PPD";
     std::string buf;
     if (!base::ReadFileToStringWithMaxSize(ppd_path, &buf,
                                            options_.max_ppd_contents_size_)) {
+      VLOG(1) << "Read bytes: " << buf.size()
+              << " max: " << options_.max_ppd_contents_size_;
+      LOG(WARNING) << "Failed to read ppd file " << ppd_path.value();
       return false;
     }
     return static_cast<bool>(cache_->Store(ppd_reference, buf));
   }
 
  private:
   // Trivial wrappers around PpdCache::Find() and
   // PpdCache::FindAvailablePrinters().  We need these wrappers both because we
   // use weak_ptrs to manage lifetime, and so we need to bind callbacks to
   // *this*, and because weak_ptr's preclude return values in posted tasks, so
   // we have to use a parameter to return state.
   void ResolveDoCacheLookup(
       const Printer::PpdReference& reference,
       base::Optional<base::FilePath>* cache_result) const {
+    VLOG(1) << "Checking cache for result";
     *cache_result = cache_->Find(reference);
+    VLOG(1) << "result found? " << cache_result->has_value();
   }
 
   void QueryAvailableDoCacheLookup(
       base::Optional<const PpdProvider::AvailablePrintersMap*>* cache_result)
       const {
     DCHECK(cache_result);
     auto tmp = cache_->FindAvailablePrinters();
     if (tmp != nullptr) {
       *cache_result = tmp;
     } else {
       *cache_result = base::nullopt;
     }
   }
 
   // Callback that happens when the Resolve() cache lookup completes.  If the
   // cache satisfied the request, finish the Resolve, otherwise start a URL
   // request to satisfy the request.  This runs on the same thread as Resolve()
   // was invoked on.
   void ResolveCacheLookupDone(
       const Printer::PpdReference& ppd_reference,
       const PpdProvider::ResolveCallback& done_callback,
       const std::unique_ptr<base::Optional<base::FilePath>>& cache_result) {
     CHECK(resolve_sequence_checker_.CalledOnValidSequence());
     if (*cache_result) {
+      VLOG(1) << "Cache hit!";
       // Cache hit.  Schedule the callback now and return.
       resolve_inflight_ = false;
       done_callback.Run(PpdProvider::SUCCESS, cache_result->value());
       return;
     }
 
     // We don't have a way to automatically resolve user-supplied PPDs yet.  So
     // if we have one specified, and it's not cached, we fail out rather than
     // fall back to quirks-server based resolution.  The reasoning here is that
     // if the user has specified a PPD when a quirks-server one exists, it
     // probably means the quirks server one doesn't work for some reason, so we
     // shouldn't silently use it.
     if (!ppd_reference.user_supplied_ppd_url.empty()) {
+      VLOG(1) << "Input error";
       resolve_inflight_ = false;
       done_callback.Run(PpdProvider::NOT_FOUND, base::FilePath());
       return;
     }
 
+    VLOG(1) << "Perform PPD download";
     // Missed in the cache, so start a URLRequest to resolve the request.
     resolve_fetcher_delegate_ = base::MakeUnique<ForwardingURLFetcherDelegate>(
         base::Bind(&PpdProviderImpl::OnResolveFetchComplete,
                    weak_factory_.GetWeakPtr(), ppd_reference, done_callback));
 
     resolve_fetcher_ = net::URLFetcher::Create(
         GetQuirksServerPpdLookupURL(ppd_reference), net::URLFetcher::GET,
         resolve_fetcher_delegate_.get());
 
     resolve_fetcher_->SetRequestContext(url_context_getter_.get());
@@ skipping 231 matching lines @@
     scoped_refptr<net::URLRequestContextGetter> url_context_getter,
     scoped_refptr<base::SequencedTaskRunner> io_task_runner,
     std::unique_ptr<PpdCache> cache,
     const PpdProvider::Options& options) {
   return base::MakeUnique<PpdProviderImpl>(
       api_key, url_context_getter, io_task_runner, std::move(cache), options);
 }
 
 }  // namespace printing
 }  // namespace chromeos