contacts: Add GDataContactsService.

chrome/browser/chromeos/gdata/fake_gdata_contacts_service.h

+// Copyright (c) 2012 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_BROWSER_CHROMEOS_GDATA_FAKE_GDATA_CONTACTS_SERVICE_H_
+#define CHROME_BROWSER_CHROMEOS_GDATA_FAKE_GDATA_CONTACTS_SERVICE_H_
+
+#include "chrome/browser/chromeos/gdata/gdata_contacts_service.h"
+
+#include "base/basictypes.h"
+#include "base/callback.h"
+#include "base/compiler_specific.h"
+#include "base/time.h"
+
+namespace contacts {
+typedef std::vector<const contacts::Contact*> ContactPointers;
+}
+
+namespace gdata {
+
+class FakeGDataContactsService : public GDataContactsServiceInterface {

[satorux1, 2012/07/24 18:25:51]

class comment is missing. is this only used for testing?

I guess we can use gmock for this, but setting expectations for functions that
take callbacks is not easy with gmock, so doing this without gmock may be
easier, though gmock is heavily used in this directory.

BTW, I'm always confused about the difference between fake and mock
implementations. Why is this Fake not Mock?

[Daniel Erat, 2012/07/24 20:37:21]

I'm really not a Gmock fan. :-)
I'm always confused about this too.  The internal writing that I looked at was
similar to http://martinfowler.com/articles/mocksArentStubs.html:

"Dummy objects are passed around but never actually used. Usually they are just
used to fill parameter lists.

Fake objects actually have working implementations, but usually take some
shortcut which makes them not suitable for production (an in memory database is
a good example).

Stubs provide canned answers to calls made during the test, usually not
responding at all to anything outside what's programmed in for the test. Stubs
may also record information about calls, such as an email gateway stub that
remembers the messages it 'sent', or maybe only how many messages it 'sent'.

Mocks are what we are talking about here: objects pre-programmed with
expectations which form a specification of the calls they are expected to
receive."

So "mock" applies to Gmock, since Gmock lets/makes you supply expectations for
how your class will be invoked.  This class doesn't do that.  "Stub" is probably
more accurate than "Fake" here.  I'll rename this to GDataContactsServiceStub
and add a comment, if that sounds okay to you.

+ public:
+  FakeGDataContactsService();
+  virtual ~FakeGDataContactsService();
+
+  void set_download_should_succeed(bool succeed) {
+    download_should_succeed_ = succeed;
+  }
+
+  void SetContacts(const contacts::ContactPointers& contacts,

[satorux1, 2012/07/24 18:25:51]

function comment?

[Daniel Erat, 2012/07/24 20:37:21]

Done.

+                   const base::Time& expected_min_update_time);
+
+  // Overridden from GDataContactsServiceInterface:
+  virtual void Initialize() OVERRIDE;
+  virtual void DownloadContacts(SuccessCallback success_callback,
+                                FailureCallback failure_callback,
+                                const base::Time& min_update_time) OVERRIDE;
+
+ private:
+  // Should calls to DownloadContacts() succeed?
+  bool download_should_succeed_;
+
+  // Contacts to be returned by calls to DownloadContacts().
+  ScopedVector<contacts::Contact> contacts_;
+
+  // |min_update_time| value that we expect to be passed to DownloadContacts().
+  // If a different value is passed, we'll log an error and report failure.
+  base::Time expected_min_update_time_;
+
+  DISALLOW_COPY_AND_ASSIGN(FakeGDataContactsService);
+};
+
+}  // namespace gdata
+
+#endif  // CHROME_BROWSER_CHROMEOS_GDATA_FAKE_GDATA_CONTACTS_SERVICE_H_