Updated comments for gcdPrivate API.

chrome/browser/local_discovery/privet_url_fetcher.cc

 // Copyright 2013 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/local_discovery/privet_url_fetcher.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/json/json_reader.h"
@@ skipping 265 matching lines @@
       delegate_->OnError(this, URL_FETCH_ERROR);
       return true;
     }
 
     return delegate_->OnRawData(this, false, response_str, base::FilePath());
   }
 }
 
 void PrivetURLFetcher::OnURLFetchCompleteParseData(
     const net::URLFetcher* source) {
-  if (source->GetResponseCode() != net::HTTP_OK) {
+  // Response contains error description.
+  bool is_error_response = false;
+  if (v3_mode_ && source->GetResponseCode() == net::HTTP_BAD_REQUEST) {
+    is_error_response = true;
+  } else if (source->GetResponseCode() != net::HTTP_OK) {
     delegate_->OnError(this, RESPONSE_CODE_ERROR);
     return;
   }
 
   std::string response_str;
-
   if (!source->GetResponseAsString(&response_str)) {
     delegate_->OnError(this, URL_FETCH_ERROR);
     return;
   }
 
   base::JSONReader json_reader(base::JSON_ALLOW_TRAILING_COMMAS);
   scoped_ptr<base::Value> value;
 
   value.reset(json_reader.ReadToValue(response_str));
 
   if (!value) {
     delegate_->OnError(this, JSON_PARSE_ERROR);
     return;
   }
 
   const base::DictionaryValue* dictionary_value = NULL;
 
   if (!value->GetAsDictionary(&dictionary_value)) {
     delegate_->OnError(this, JSON_PARSE_ERROR);
     return;
   }
 
   std::string error;
-  if (dictionary_value->GetString(kPrivetKeyError, &error)) {
+  if (!v3_mode_ && dictionary_value->GetString(kPrivetKeyError, &error)) {
     if (error == kPrivetErrorInvalidXPrivetToken) {
       RequestTokenRefresh();
       return;
     } else if (PrivetErrorTransient(error)) {
       if (!do_not_retry_on_transient_error_) {
         int timeout_seconds;
         if (!dictionary_value->GetInteger(kPrivetKeyTimeout,
                                           &timeout_seconds)) {
           timeout_seconds = kPrivetDefaultTimeout;
         }
 
         ScheduleRetry(timeout_seconds);
         return;
       }
     }
+    is_error_response = true;
   }
 
-  delegate_->OnParsedJson(
-      this, *dictionary_value, dictionary_value->HasKey(kPrivetKeyError));
+  delegate_->OnParsedJson(this, *dictionary_value, is_error_response);
 }
 
 void PrivetURLFetcher::ScheduleRetry(int timeout_seconds) {
   double random_scaling_factor =
       1 + base::RandDouble() * kPrivetMaximumTimeRandomAddition;
 
   int timeout_seconds_randomized =
       static_cast<int>(timeout_seconds * random_scaling_factor);
 
   timeout_seconds_randomized =
@@ skipping 21 matching lines @@
 }
 
 bool PrivetURLFetcher::PrivetErrorTransient(const std::string& error) {
   return (error == kPrivetErrorDeviceBusy) ||
          (error == kPrivetV3ErrorDeviceBusy) ||
          (error == kPrivetErrorPendingUserAction) ||
          (error == kPrivetErrorPrinterBusy);
 }
 
 }  // namespace local_discovery